Subversion Repositories SmartDukaan

Rev

Rev 4763 | Rev 4789 | 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 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
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 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4763 rajveer 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
4763 rajveer 336 
     - authorize
3064 chandransh 337 
    """
338 
    pass
339 
 
4763 rajveer 340 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 341 
    """
342 
    Add the invoice number to the order.
343 
 
344 
    Parameters:
345 
     - orderId
346 
     - invoiceNumber
4763 rajveer 347 
     - color
4579 rajveer 348 
    """
349 
    pass
350 
 
3064 chandransh 351 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 354 
    given warehouse and were picked up by the given provider as MANIFESTED.
355 
 
356 
    Parameters:
357 
     - warehouseId
358 
     - providerId
359 
     - cod
360 
    """
361 
    pass
362 
 
363 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
364 
    """
365 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 366 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 367 
 
3064 chandransh 368 
    Parameters:
759 chandransh 369 
     - warehouseId
370 
     - providerId
3064 chandransh 371 
     - cod
759 chandransh 372 
    """
373 
    pass
374 
 
1113 chandransh 375 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
376 
    """
377 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
378 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 380 
 
1113 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - pickupDetails
384 
    """
385 
    pass
386 
 
1132 chandransh 387 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
388 
    """
389 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
390 
    the name of the receiver.
391 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 392 
 
1132 chandransh 393 
    Parameters:
394 
     - providerId
395 
     - deliveredOrders
396 
    """
397 
    pass
398 
 
1135 chandransh 399 
  def markOrdersAsFailed(self, providerId, returnedOrders):
400 
    """
401 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
402 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 403 
 
1135 chandransh 404 
    Parameters:
405 
     - providerId
406 
     - returnedOrders
407 
    """
408 
    pass
409 
 
1246 chandransh 410 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
411 
    """
412 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 413 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 414 
 
1246 chandransh 415 
    Parameters:
416 
     - providerId
417 
     - undeliveredOrders
418 
    """
419 
    pass
420 
 
1408 ankur.sing 421 
  def getUndeliveredOrders(self, providerId, warehouseId):
422 
    """
423 
    Returns the list of orders whose delivery time has passed but have not been
424 
    delivered yet for the given provider and warehouse. To get a complete list of
425 
    undelivered orders, pass them as -1.
426 
    Returns an empty list if no such orders exist.
3431 rajveer 427 
 
1408 ankur.sing 428 
    Parameters:
429 
     - providerId
430 
     - warehouseId
431 
    """
432 
    pass
433 
 
4783 phani.kuma 434 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
435 
    """
436 
    Returns the list of orders whose expected delivery date has passed but have not been
437 
    delivered yet.
438 
    Returns an empty list if no such orders exist.
439 
    """
440 
    pass
441 
 
2536 chandransh 442 
  def toggleDOAFlag(self, orderId):
443 
    """
444 
    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.
445 
    Returns the final flag status.
446 
    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 447 
 
2536 chandransh 448 
    Parameters:
449 
     - orderId
450 
    """
451 
    pass
1886 ankur.sing 452 
 
4712 rajveer 453 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
454 
    """
455 
    Parameters:
456 
     - orderId
457 
     - deliveryTimestamp
458 
     - receiver
459 
    """
460 
    pass
461 
 
4454 rajveer 462 
  def markOrderDoaRequestReceived(self, orderId):
463 
    """
464 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
465 
 
466 
    Parameters:
467 
     - orderId
468 
    """
469 
    pass
470 
 
471 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
472 
    """
473 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
474 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
475 
 
476 
    Parameters:
477 
     - orderId
478 
     - isAuthorized
479 
    """
480 
    pass
481 
 
4488 rajveer 482 
  def markOrderReturnRequestReceived(self, orderId):
483 
    """
484 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
485 
 
486 
    Parameters:
487 
     - orderId
488 
    """
489 
    pass
490 
 
491 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
492 
    """
493 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
494 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
495 
 
496 
    Parameters:
497 
     - orderId
498 
     - isAuthorized
499 
    """
500 
    pass
501 
 
4579 rajveer 502 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 503 
    """
504 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 505 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
506 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 507 
    For any other status, it returns false.
508 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 509 
 
2536 chandransh 510 
    Parameters:
511 
     - orderId
4579 rajveer 512 
     - providerId
2536 chandransh 513 
    """
514 
    pass
515 
 
4602 rajveer 516 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 517 
    """
4452 rajveer 518 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 519 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
520 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
521 
    	3. Returns true
2591 chandransh 522 
    If the order is in any other status, it returns false.
2536 chandransh 523 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 524 
 
2536 chandransh 525 
    Parameters:
526 
     - orderId
527 
     - pickupNumber
4602 rajveer 528 
     - providerId
2536 chandransh 529 
    """
530 
    pass
531 
 
2764 chandransh 532 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
533 
    """
534 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
535 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 536 
 
2764 chandransh 537 
    Parameters:
538 
     - providerId
539 
     - pickupDetails
540 
    """
541 
    pass
542 
 
4741 phani.kuma 543 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
544 
    """
545 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
546 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
547 
 
548 
    Parameters:
549 
     - providerId
550 
     - pickupDetails
551 
    """
552 
    pass
553 
 
4479 rajveer 554 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 555 
    """
4452 rajveer 556 
    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 557 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 558 
    If the order is in any other state, it returns false.
559 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 560 
 
2591 chandransh 561 
    Parameters:
562 
     - orderId
4479 rajveer 563 
     - receiveCondition
2591 chandransh 564 
    """
565 
    pass
2536 chandransh 566 
 
2591 chandransh 567 
  def validateDoa(self, orderId, isValid):
568 
    """
4452 rajveer 569 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 570 
    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 571 
    If the order is in any other state, it returns false.
572 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 573 
 
2591 chandransh 574 
    Parameters:
575 
     - orderId
576 
     - isValid
577 
    """
578 
    pass
579 
 
4495 rajveer 580 
  def validateReturnProduct(self, orderId, isUsable):
581 
    """
582 
    Parameters:
583 
     - orderId
584 
     - isUsable
585 
    """
586 
    pass
587 
 
2616 chandransh 588 
  def reshipOrder(self, orderId):
589 
    """
4484 rajveer 590 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 591 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 592 
    	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 593 
 
594 
    If the order is in DOA_CERT_VALID state, it does the following:
595 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
596 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 597 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 598 
 
2616 chandransh 599 
    Returns the id of the newly created order.
3431 rajveer 600 
 
2616 chandransh 601 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 602 
 
2616 chandransh 603 
    Parameters:
604 
     - orderId
605 
    """
606 
    pass
2591 chandransh 607 
 
3226 chandransh 608 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 609 
    """
4484 rajveer 610 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 611 
    	1. Creates a refund request for batch processing.
612 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 613 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 614 
 
2616 chandransh 615 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
616 
    	1. Creates a refund request for batch processing.
3226 chandransh 617 
    	2. Cancels the reservation of the item in the warehouse.
618 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 619 
 
3226 chandransh 620 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
621 
    	1. Cancels the reservation of the item in the warehouse.
622 
    	2. Marks the current order as CANCELED.
623 
 
624 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
625 
 
2616 chandransh 626 
    Returns True if it is successful, False otherwise.
3431 rajveer 627 
 
2616 chandransh 628 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 629 
 
2616 chandransh 630 
    Parameters:
631 
     - orderId
3226 chandransh 632 
     - refundedBy
633 
     - reason
2616 chandransh 634 
    """
635 
    pass
636 
 
2690 chandransh 637 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
638 
    """
639 
    Get all return orders created between the from and to dates for the given warehouse.
640 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 641 
 
2690 chandransh 642 
    Parameters:
643 
     - warehouseId
644 
     - fromDate
645 
     - toDate
646 
    """
647 
    pass
2616 chandransh 648 
 
2700 chandransh 649 
  def getReturnOrder(self, id):
650 
    """
651 
    Returns the ReturnOrder corresponding to the given id.
652 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 653 
 
2700 chandransh 654 
    Parameters:
655 
     - id
656 
    """
657 
    pass
658 
 
2690 chandransh 659 
  def processReturn(self, returnOrderId):
660 
    """
661 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 662 
 
2690 chandransh 663 
    Parameters:
664 
     - returnOrderId
665 
    """
666 
    pass
667 
 
3451 chandransh 668 
  def updateWeight(self, orderId, weight):
669 
    """
670 
    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 671 
 
3451 chandransh 672 
    Parameters:
673 
     - orderId
674 
     - weight
675 
    """
676 
    pass
677 
 
3469 chandransh 678 
  def changeItem(self, orderId, itemId):
679 
    """
680 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
681 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 682 
 
3469 chandransh 683 
    Parameters:
684 
     - orderId
685 
     - itemId
686 
    """
687 
    pass
688 
 
689 
  def shiftToWarehouse(self, orderId, warehouseId):
690 
    """
691 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
692 
 
693 
    Parameters:
694 
     - orderId
695 
     - warehouseId
696 
    """
697 
    pass
698 
 
4647 rajveer 699 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 700 
    """
701 
    Adds the given delay reason to the given order.
3986 chandransh 702 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 703 
    Raises an exception if no order with the given id can be found.
3469 chandransh 704 
 
3553 chandransh 705 
    Parameters:
706 
     - orderId
707 
     - delayReason
3986 chandransh 708 
     - furtherDelay
4647 rajveer 709 
     - delayReasonText
3553 chandransh 710 
    """
711 
    pass
712 
 
3956 chandransh 713 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
714 
    """
715 
    Marks the COD orders with given AWB nos. as having been processed.
716 
    Updates the captured amount for the corresponding payment.
3553 chandransh 717 
 
3956 chandransh 718 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
719 
    1. There is no order corresponding to an AWB number.
720 
    2. The captured amount for a payment exceeds the total payment.
721 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
722 
 
723 
    Parameters:
724 
     - collectedAmountMap
725 
     - xferBy
726 
     - xferTxnId
727 
     - xferDate
728 
    """
729 
    pass
730 
 
4008 mandeep.dh 731 
  def getTransactionsRequiringExtraProcessing(self, category):
732 
    """
4065 mandeep.dh 733 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 734 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 735 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 736 
 
4008 mandeep.dh 737 
    Parameters:
738 
     - category
739 
    """
740 
    pass
741 
 
742 
  def markTransactionAsProcessed(self, transactionId, category):
743 
    """
744 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 745 
    It essentially deletes the transaction id record for a particular
746 
    processing type category (if present) from DB.
747 
    This is currently used by CRM application.
4008 mandeep.dh 748 
 
749 
    Parameters:
750 
     - transactionId
751 
     - category
752 
    """
753 
    pass
754 
 
4018 chandransh 755 
  def getItemWiseRiskyOrdersCount(self, ):
756 
    """
757 
    Returns a map containing the number of risky orders keyed by item id. A risky order
758 
    is defined as one whose shipping date is about to expire.
759 
    """
760 
    pass
4008 mandeep.dh 761 
 
4295 varun.gupt 762 
  def getOrdersForItemIds(self, itemIds):
763 
    """
764 
    Returns a list of all orders which have items with given id
765 
 
766 
    Parameters:
767 
     - itemIds
768 
    """
769 
    pass
770 
 
4247 rajveer 771 
  def markOrderCancellationRequestReceived(self, orderId):
772 
    """
773 
    Mark order as cancellation request received. If customer sends request of cancellation of
774 
    a particular order, this method will be called. It will just change status of the order
775 
    depending on its current status. It also records the previous status, so that we can move
776 
    back to that status if cancellation request is denied.
4018 chandransh 777 
 
4247 rajveer 778 
    Parameters:
779 
     - orderId
780 
    """
781 
    pass
782 
 
783 
  def markOrderCancellationRequestConfirmed(self, orderId):
784 
    """
785 
    If we decide to to cancel order, CRM will call this method to move the status of order to
786 
    cancellation request confirmed. After this OM will be able to cancel the order.
787 
 
788 
    Parameters:
789 
     - orderId
790 
    """
791 
    pass
792 
 
793 
  def markOrderCancellationRequestDenied(self, orderId):
794 
    """
795 
    If we decide to not to cancel order, we will move the order ro previous status.
796 
 
797 
    Parameters:
798 
     - orderId
799 
    """
800 
    pass
801 
 
4258 rajveer 802 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 803 
    """
4258 rajveer 804 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
805 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 806 
 
807 
    Parameters:
4258 rajveer 808 
     - transactionId
4247 rajveer 809 
    """
810 
    pass
811 
 
4259 anupam.sin 812 
  def refundTransaction(self, transactionId, refundedBy, reason):
813 
    """
814 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
815 
    need to be cancelled
4247 rajveer 816 
 
4259 anupam.sin 817 
    Parameters:
818 
     - transactionId
819 
     - refundedBy
820 
     - reason
821 
    """
822 
    pass
823 
 
4324 mandeep.dh 824 
  def updateShipmentAddress(self, orderId, addressId):
825 
    """
826 
    Updates shipment address of an order. Delivery and shipping date estimates
827 
    etc. are also updated here.
828 
 
829 
    Throws TransactionServiceException in case address change is not
830 
    possible due to certain reasons such as new pincode in address is
831 
    not serviceable etc.
832 
 
833 
    Parameters:
834 
     - orderId
835 
     - addressId
836 
    """
837 
    pass
838 
 
4285 rajveer 839 
  def acceptOrdersForItemId(self, itemId, inventory):
840 
    """
841 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
842 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 843 
 
4285 rajveer 844 
    Parameters:
845 
     - itemId
846 
     - inventory
847 
    """
848 
    pass
849 
 
4369 rajveer 850 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 851 
    """
852 
    Parameters:
853 
     - vendorId
854 
     - itemId
855 
     - quantity
856 
     - estimate
4369 rajveer 857 
     - isReminder
4303 rajveer 858 
    """
859 
    pass
4285 rajveer 860 
 
4369 rajveer 861 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 862 
    """
863 
    Parameters:
864 
     - vendorId
865 
     - itemId
866 
     - quantity
867 
     - estimate
4369 rajveer 868 
     - isReminder
4303 rajveer 869 
    """
870 
    pass
871 
 
4369 rajveer 872 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 873 
    """
874 
    Parameters:
875 
     - vendorId
876 
     - itemId
877 
     - quantity
878 
     - estimate
4369 rajveer 879 
     - isReminder
4303 rajveer 880 
    """
881 
    pass
882 
 
4369 rajveer 883 
  def markOrdersAsTimeout(self, vendorId):
884 
    """
885 
    Parameters:
886 
     - vendorId
887 
    """
888 
    pass
4303 rajveer 889 
 
4662 rajveer 890 
  def markOrderAsLostInTransit(self, orderId):
891 
    """
892 
    Mark order as LOST_IN_TRANSIT
893 
 
894 
    Parameters:
895 
     - orderId
896 
    """
897 
    pass
898 
 
4386 anupam.sin 899 
  def getOrderForAwb(self, awb):
900 
    """
901 
    Returns the order corresponding to an AWB number
4369 rajveer 902 
 
4386 anupam.sin 903 
    Parameters:
904 
     - awb
905 
    """
906 
    pass
907 
 
4506 phani.kuma 908 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
909 
    """
910 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 911 
 
4506 phani.kuma 912 
    Parameters:
913 
     - logistics_provider_id
914 
     - order_status
915 
    """
916 
    pass
917 
 
4600 varun.gupt 918 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
919 
    """
920 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 921 
 
4600 varun.gupt 922 
    Parameters:
923 
     - vendorId
924 
     - billingDateFrom
925 
     - billingDateTo
926 
    """
927 
    pass
928 
 
4607 rajveer 929 
  def getSlippedSippingDateOrders(self, ):
930 
    pass
931 
 
4709 rajveer 932 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
933 
    """
934 
    Parameters:
935 
     - cancelDateFrom
936 
     - cancelDateTo
937 
    """
938 
    pass
939 
 
4600 varun.gupt 940 
  def saveBluedartSettlements(self, mapAWBAndAmount):
941 
    """
942 
    Parameters:
943 
     - mapAWBAndAmount
944 
    """
945 
    pass
946 
 
947 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
948 
    """
949 
    Parameters:
950 
     - settlementDate
951 
     - paymentGatewayId
952 
     - paymentId
953 
     - serviceTax
954 
     - otherCharges
955 
     - netCollection
956 
    """
957 
    pass
958 
 
959 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
960 
    """
961 
    Parameters:
962 
     - settlementId
963 
     - settlementDate
964 
     - transactionDateFrom
965 
     - transactionDateTo
966 
     - amount
967 
    """
968 
    pass
969 
 
970 
  def getSettlementForPaymentId(self, paymentId):
971 
    """
972 
    Parameters:
973 
     - paymentId
974 
    """
975 
    pass
976 
 
977 
  def getEBSSettlementSummaries(self, ):
978 
    pass
979 
 
980 
  def markEBSSettlementUploaded(self, settlementId):
981 
    """
982 
    Parameters:
983 
     - settlementId
984 
    """
985 
    pass
986 
 
987 
  def getEBSSettlementDate(self, settlementId):
988 
    """
989 
    Parameters:
990 
     - settlementId
991 
    """
992 
    pass
993 
 
4715 varun.gupt 994 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
995 
    """
996 
    Parameters:
997 
     - settlementDateFrom
998 
     - settlementDateTo
999 
     - isRefund
1000 
    """
1001 
    pass
4600 varun.gupt 1002 
 
4715 varun.gupt 1003 
  def getReshippedOrderIds(self, orderIds):
1004 
    """
1005 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1006 
 
1007 
    Parameters:
1008 
     - orderIds
1009 
    """
1010 
    pass
1011 
 
4757 mandeep.dh 1012 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1013 
    """
1014 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1015 
    the quantities for which the PO is raised.
4715 varun.gupt 1016 
 
4757 mandeep.dh 1017 
    Parameters:
1018 
     - itemIdQuantityMap
1019 
     - purchaseOrderId
1020 
     - warehouseId
1021 
    """
1022 
    pass
1023 
 
1024 
 
3376 rajveer 1025 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1026 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1027 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1028 
 
1029 
  def createTransaction(self, transaction):
1030 
    """
1031 
    Parameters:
1032 
     - transaction
1033 
    """
1034 
    self.send_createTransaction(transaction)
132 ashish 1035 
    return self.recv_createTransaction()
94 ashish 1036 
 
1037 
  def send_createTransaction(self, transaction):
1038 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1039 
    args = createTransaction_args()
1040 
    args.transaction = transaction
1041 
    args.write(self._oprot)
1042 
    self._oprot.writeMessageEnd()
1043 
    self._oprot.trans.flush()
1044 
 
1045 
  def recv_createTransaction(self, ):
1046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1047 
    if mtype == TMessageType.EXCEPTION:
1048 
      x = TApplicationException()
1049 
      x.read(self._iprot)
1050 
      self._iprot.readMessageEnd()
1051 
      raise x
1052 
    result = createTransaction_result()
1053 
    result.read(self._iprot)
1054 
    self._iprot.readMessageEnd()
3431 rajveer 1055 
    if result.success is not None:
132 ashish 1056 
      return result.success
3431 rajveer 1057 
    if result.ex is not None:
94 ashish 1058 
      raise result.ex
132 ashish 1059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1060 
 
1061 
  def getTransaction(self, id):
1062 
    """
1063 
    Parameters:
1064 
     - id
1065 
    """
1066 
    self.send_getTransaction(id)
1067 
    return self.recv_getTransaction()
1068 
 
1069 
  def send_getTransaction(self, id):
1070 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1071 
    args = getTransaction_args()
1072 
    args.id = id
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_getTransaction(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = getTransaction_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
3431 rajveer 1087 
    if result.success is not None:
94 ashish 1088 
      return result.success
3431 rajveer 1089 
    if result.ex is not None:
94 ashish 1090 
      raise result.ex
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1092 
 
1093 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1094 
    """
1095 
    Parameters:
1096 
     - customerId
1097 
     - from_date
1098 
     - to_date
1099 
     - status
1100 
    """
1101 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1102 
    return self.recv_getTransactionsForCustomer()
1103 
 
1104 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1105 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1106 
    args = getTransactionsForCustomer_args()
1107 
    args.customerId = customerId
1108 
    args.from_date = from_date
1109 
    args.to_date = to_date
1110 
    args.status = status
1111 
    args.write(self._oprot)
1112 
    self._oprot.writeMessageEnd()
1113 
    self._oprot.trans.flush()
1114 
 
1115 
  def recv_getTransactionsForCustomer(self, ):
1116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1117 
    if mtype == TMessageType.EXCEPTION:
1118 
      x = TApplicationException()
1119 
      x.read(self._iprot)
1120 
      self._iprot.readMessageEnd()
1121 
      raise x
1122 
    result = getTransactionsForCustomer_result()
1123 
    result.read(self._iprot)
1124 
    self._iprot.readMessageEnd()
3431 rajveer 1125 
    if result.success is not None:
94 ashish 1126 
      return result.success
3431 rajveer 1127 
    if result.ex is not None:
94 ashish 1128 
      raise result.ex
1129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1130 
 
132 ashish 1131 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1132 
    """
1133 
    Parameters:
1134 
     - shoppingCartId
1135 
    """
1136 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1137 
    return self.recv_getTransactionsForShoppingCartId()
1138 
 
1139 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1140 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1141 
    args = getTransactionsForShoppingCartId_args()
1142 
    args.shoppingCartId = shoppingCartId
1143 
    args.write(self._oprot)
1144 
    self._oprot.writeMessageEnd()
1145 
    self._oprot.trans.flush()
1146 
 
1147 
  def recv_getTransactionsForShoppingCartId(self, ):
1148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1149 
    if mtype == TMessageType.EXCEPTION:
1150 
      x = TApplicationException()
1151 
      x.read(self._iprot)
1152 
      self._iprot.readMessageEnd()
1153 
      raise x
1154 
    result = getTransactionsForShoppingCartId_result()
1155 
    result.read(self._iprot)
1156 
    self._iprot.readMessageEnd()
3431 rajveer 1157 
    if result.success is not None:
132 ashish 1158 
      return result.success
3431 rajveer 1159 
    if result.ex is not None:
132 ashish 1160 
      raise result.ex
1161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1162 
 
94 ashish 1163 
  def getTransactionStatus(self, transactionId):
1164 
    """
1165 
    Parameters:
1166 
     - transactionId
1167 
    """
1168 
    self.send_getTransactionStatus(transactionId)
1169 
    return self.recv_getTransactionStatus()
1170 
 
1171 
  def send_getTransactionStatus(self, transactionId):
1172 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1173 
    args = getTransactionStatus_args()
1174 
    args.transactionId = transactionId
1175 
    args.write(self._oprot)
1176 
    self._oprot.writeMessageEnd()
1177 
    self._oprot.trans.flush()
1178 
 
1179 
  def recv_getTransactionStatus(self, ):
1180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1181 
    if mtype == TMessageType.EXCEPTION:
1182 
      x = TApplicationException()
1183 
      x.read(self._iprot)
1184 
      self._iprot.readMessageEnd()
1185 
      raise x
1186 
    result = getTransactionStatus_result()
1187 
    result.read(self._iprot)
1188 
    self._iprot.readMessageEnd()
3431 rajveer 1189 
    if result.success is not None:
94 ashish 1190 
      return result.success
3431 rajveer 1191 
    if result.ex is not None:
94 ashish 1192 
      raise result.ex
1193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1194 
 
1195 
  def changeTransactionStatus(self, transactionId, status, description):
1196 
    """
1197 
    Parameters:
1198 
     - transactionId
1199 
     - status
1200 
     - description
1201 
    """
1202 
    self.send_changeTransactionStatus(transactionId, status, description)
1203 
    return self.recv_changeTransactionStatus()
1204 
 
1205 
  def send_changeTransactionStatus(self, transactionId, status, description):
1206 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1207 
    args = changeTransactionStatus_args()
1208 
    args.transactionId = transactionId
1209 
    args.status = status
1210 
    args.description = description
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_changeTransactionStatus(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = changeTransactionStatus_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
94 ashish 1226 
      return result.success
3431 rajveer 1227 
    if result.ex is not None:
94 ashish 1228 
      raise result.ex
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1230 
 
1398 varun.gupt 1231 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1232 
    """
1233 
    Parameters:
1234 
     - transactionId
1235 
    """
1398 varun.gupt 1236 
    self.send_enqueueTransactionInfoEmail(transactionId)
1237 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1238 
 
1398 varun.gupt 1239 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1240 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1241 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1242 
    args.transactionId = transactionId
1243 
    args.write(self._oprot)
1244 
    self._oprot.writeMessageEnd()
1245 
    self._oprot.trans.flush()
1246 
 
1398 varun.gupt 1247 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1249 
    if mtype == TMessageType.EXCEPTION:
1250 
      x = TApplicationException()
1251 
      x.read(self._iprot)
1252 
      self._iprot.readMessageEnd()
1253 
      raise x
1398 varun.gupt 1254 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1255 
    result.read(self._iprot)
1256 
    self._iprot.readMessageEnd()
3431 rajveer 1257 
    if result.success is not None:
1382 varun.gupt 1258 
      return result.success
3431 rajveer 1259 
    if result.ex is not None:
1382 varun.gupt 1260 
      raise result.ex
1398 varun.gupt 1261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1262 
 
483 rajveer 1263 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1264 
    """
1265 
    Parameters:
483 rajveer 1266 
     - status
1267 
     - from_date
1268 
     - to_date
1269 
     - warehouse_id
94 ashish 1270 
    """
483 rajveer 1271 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1272 
    return self.recv_getAllOrders()
94 ashish 1273 
 
483 rajveer 1274 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1275 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1276 
    args = getAllOrders_args()
1277 
    args.status = status
1278 
    args.from_date = from_date
1279 
    args.to_date = to_date
1280 
    args.warehouse_id = warehouse_id
94 ashish 1281 
    args.write(self._oprot)
1282 
    self._oprot.writeMessageEnd()
1283 
    self._oprot.trans.flush()
1284 
 
483 rajveer 1285 
  def recv_getAllOrders(self, ):
94 ashish 1286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1287 
    if mtype == TMessageType.EXCEPTION:
1288 
      x = TApplicationException()
1289 
      x.read(self._iprot)
1290 
      self._iprot.readMessageEnd()
1291 
      raise x
483 rajveer 1292 
    result = getAllOrders_result()
94 ashish 1293 
    result.read(self._iprot)
1294 
    self._iprot.readMessageEnd()
3431 rajveer 1295 
    if result.success is not None:
94 ashish 1296 
      return result.success
3431 rajveer 1297 
    if result.ex is not None:
94 ashish 1298 
      raise result.ex
483 rajveer 1299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1300 
 
4133 chandransh 1301 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1302 
    """
1303 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1304 
    Pass the status as null and the limit as 0 to ignore them.
1305 
 
1306 
    Parameters:
1307 
     - statuses
1308 
     - offset
1309 
     - limit
1310 
     - warehouse_id
1311 
    """
1312 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1313 
    return self.recv_getOrdersInBatch()
1314 
 
1315 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1316 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1317 
    args = getOrdersInBatch_args()
1318 
    args.statuses = statuses
1319 
    args.offset = offset
1320 
    args.limit = limit
1321 
    args.warehouse_id = warehouse_id
1322 
    args.write(self._oprot)
1323 
    self._oprot.writeMessageEnd()
1324 
    self._oprot.trans.flush()
1325 
 
1326 
  def recv_getOrdersInBatch(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 = getOrdersInBatch_result()
1334 
    result.read(self._iprot)
1335 
    self._iprot.readMessageEnd()
1336 
    if result.success is not None:
1337 
      return result.success
1338 
    if result.ex is not None:
1339 
      raise result.ex
1340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1341 
 
1342 
  def getOrderCount(self, statuses, warehouseId):
1343 
    """
1344 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1345 
 
1346 
    Parameters:
1347 
     - statuses
1348 
     - warehouseId
1349 
    """
1350 
    self.send_getOrderCount(statuses, warehouseId)
1351 
    return self.recv_getOrderCount()
1352 
 
1353 
  def send_getOrderCount(self, statuses, warehouseId):
1354 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1355 
    args = getOrderCount_args()
1356 
    args.statuses = statuses
1357 
    args.warehouseId = warehouseId
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_getOrderCount(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = getOrderCount_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
1372 
    if result.success is not None:
1373 
      return result.success
1374 
    if result.ex is not None:
1375 
      raise result.ex
1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1377 
 
999 varun.gupt 1378 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1379 
    """
1132 chandransh 1380 
    Returns orders within a range of their billing dates
3431 rajveer 1381 
 
999 varun.gupt 1382 
    Parameters:
1383 
     - status
1384 
     - start_billing_date
1385 
     - end_billing_date
1386 
     - warehouse_id
1387 
    """
1388 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1389 
    return self.recv_getOrdersByBillingDate()
1390 
 
1391 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1392 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1393 
    args = getOrdersByBillingDate_args()
1394 
    args.status = status
1395 
    args.start_billing_date = start_billing_date
1396 
    args.end_billing_date = end_billing_date
1397 
    args.warehouse_id = warehouse_id
1398 
    args.write(self._oprot)
1399 
    self._oprot.writeMessageEnd()
1400 
    self._oprot.trans.flush()
1401 
 
1402 
  def recv_getOrdersByBillingDate(self, ):
1403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1404 
    if mtype == TMessageType.EXCEPTION:
1405 
      x = TApplicationException()
1406 
      x.read(self._iprot)
1407 
      self._iprot.readMessageEnd()
1408 
      raise x
1409 
    result = getOrdersByBillingDate_result()
1410 
    result.read(self._iprot)
1411 
    self._iprot.readMessageEnd()
3431 rajveer 1412 
    if result.success is not None:
999 varun.gupt 1413 
      return result.success
3431 rajveer 1414 
    if result.ex is not None:
999 varun.gupt 1415 
      raise result.ex
1416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1417 
 
3451 chandransh 1418 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1419 
    """
1420 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1421 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1422 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1423 
 
3427 chandransh 1424 
    Parameters:
1425 
     - fromShippingDate
1426 
     - toShippingDate
1427 
     - providerId
1428 
     - warehouseId
3451 chandransh 1429 
     - cod
3427 chandransh 1430 
    """
3451 chandransh 1431 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1432 
    return self.recv_getOrdersByShippingDate()
1433 
 
3451 chandransh 1434 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1435 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1436 
    args = getOrdersByShippingDate_args()
1437 
    args.fromShippingDate = fromShippingDate
1438 
    args.toShippingDate = toShippingDate
1439 
    args.providerId = providerId
1440 
    args.warehouseId = warehouseId
3451 chandransh 1441 
    args.cod = cod
3427 chandransh 1442 
    args.write(self._oprot)
1443 
    self._oprot.writeMessageEnd()
1444 
    self._oprot.trans.flush()
1445 
 
1446 
  def recv_getOrdersByShippingDate(self, ):
1447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1448 
    if mtype == TMessageType.EXCEPTION:
1449 
      x = TApplicationException()
1450 
      x.read(self._iprot)
1451 
      self._iprot.readMessageEnd()
1452 
      raise x
1453 
    result = getOrdersByShippingDate_result()
1454 
    result.read(self._iprot)
1455 
    self._iprot.readMessageEnd()
3431 rajveer 1456 
    if result.success is not None:
3427 chandransh 1457 
      return result.success
3431 rajveer 1458 
    if result.ex is not None:
3427 chandransh 1459 
      raise result.ex
1460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1461 
 
1382 varun.gupt 1462 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1463 
    """
1464 
    Returns order ids for orders which can be returned
3431 rajveer 1465 
 
1382 varun.gupt 1466 
    Parameters:
1467 
     - customer_id
1468 
     - limit
1469 
    """
1470 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1471 
    return self.recv_getReturnableOrdersForCustomer()
1472 
 
1473 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1474 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1475 
    args = getReturnableOrdersForCustomer_args()
1476 
    args.customer_id = customer_id
1477 
    args.limit = limit
1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1482 
  def recv_getReturnableOrdersForCustomer(self, ):
1483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1484 
    if mtype == TMessageType.EXCEPTION:
1485 
      x = TApplicationException()
1486 
      x.read(self._iprot)
1487 
      self._iprot.readMessageEnd()
1488 
      raise x
1489 
    result = getReturnableOrdersForCustomer_result()
1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
3431 rajveer 1492 
    if result.success is not None:
1382 varun.gupt 1493 
      return result.success
3431 rajveer 1494 
    if result.ex is not None:
1382 varun.gupt 1495 
      raise result.ex
1496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1497 
 
1498 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1499 
    """
1500 
    Returns order ids for orders which can be cancelled
3431 rajveer 1501 
 
1382 varun.gupt 1502 
    Parameters:
1503 
     - customer_id
1504 
     - limit
1505 
    """
1506 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1507 
    return self.recv_getCancellableOrdersForCustomer()
1508 
 
1509 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1510 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1511 
    args = getCancellableOrdersForCustomer_args()
1512 
    args.customer_id = customer_id
1513 
    args.limit = limit
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getCancellableOrdersForCustomer(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getCancellableOrdersForCustomer_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
3431 rajveer 1528 
    if result.success is not None:
1382 varun.gupt 1529 
      return result.success
3431 rajveer 1530 
    if result.ex is not None:
1382 varun.gupt 1531 
      raise result.ex
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1533 
 
483 rajveer 1534 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1535 
    """
1536 
    Parameters:
483 rajveer 1537 
     - orderId
1538 
     - status
1539 
     - description
94 ashish 1540 
    """
483 rajveer 1541 
    self.send_changeOrderStatus(orderId, status, description)
1542 
    return self.recv_changeOrderStatus()
94 ashish 1543 
 
483 rajveer 1544 
  def send_changeOrderStatus(self, orderId, status, description):
1545 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1546 
    args = changeOrderStatus_args()
1547 
    args.orderId = orderId
1548 
    args.status = status
1549 
    args.description = description
94 ashish 1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
483 rajveer 1554 
  def recv_changeOrderStatus(self, ):
94 ashish 1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
483 rajveer 1561 
    result = changeOrderStatus_result()
94 ashish 1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
3431 rajveer 1564 
    if result.success is not None:
94 ashish 1565 
      return result.success
3431 rajveer 1566 
    if result.ex is not None:
94 ashish 1567 
      raise result.ex
483 rajveer 1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1569 
 
1528 ankur.sing 1570 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1571 
    """
1528 ankur.sing 1572 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1573 
    only user who owns the transaction can view its order details.
3431 rajveer 1574 
 
94 ashish 1575 
    Parameters:
1576 
     - transactionId
1528 ankur.sing 1577 
     - customerId
94 ashish 1578 
    """
1528 ankur.sing 1579 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1580 
    return self.recv_getOrdersForTransaction()
94 ashish 1581 
 
1528 ankur.sing 1582 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1583 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1584 
    args = getOrdersForTransaction_args()
94 ashish 1585 
    args.transactionId = transactionId
1528 ankur.sing 1586 
    args.customerId = customerId
94 ashish 1587 
    args.write(self._oprot)
1588 
    self._oprot.writeMessageEnd()
1589 
    self._oprot.trans.flush()
1590 
 
483 rajveer 1591 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1593 
    if mtype == TMessageType.EXCEPTION:
1594 
      x = TApplicationException()
1595 
      x.read(self._iprot)
1596 
      self._iprot.readMessageEnd()
1597 
      raise x
483 rajveer 1598 
    result = getOrdersForTransaction_result()
94 ashish 1599 
    result.read(self._iprot)
1600 
    self._iprot.readMessageEnd()
3431 rajveer 1601 
    if result.success is not None:
94 ashish 1602 
      return result.success
3431 rajveer 1603 
    if result.ex is not None:
94 ashish 1604 
      raise result.ex
483 rajveer 1605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1606 
 
3014 chandransh 1607 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1608 
    """
3014 chandransh 1609 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1610 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1611 
 
94 ashish 1612 
    Parameters:
483 rajveer 1613 
     - customerId
1614 
     - from_date
1615 
     - to_date
3014 chandransh 1616 
     - statuses
94 ashish 1617 
    """
3014 chandransh 1618 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1619 
    return self.recv_getOrdersForCustomer()
94 ashish 1620 
 
3014 chandransh 1621 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1622 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1623 
    args = getOrdersForCustomer_args()
1624 
    args.customerId = customerId
1625 
    args.from_date = from_date
1626 
    args.to_date = to_date
3014 chandransh 1627 
    args.statuses = statuses
94 ashish 1628 
    args.write(self._oprot)
1629 
    self._oprot.writeMessageEnd()
1630 
    self._oprot.trans.flush()
1631 
 
483 rajveer 1632 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1634 
    if mtype == TMessageType.EXCEPTION:
1635 
      x = TApplicationException()
1636 
      x.read(self._iprot)
1637 
      self._iprot.readMessageEnd()
1638 
      raise x
483 rajveer 1639 
    result = getOrdersForCustomer_result()
94 ashish 1640 
    result.read(self._iprot)
1641 
    self._iprot.readMessageEnd()
3431 rajveer 1642 
    if result.success is not None:
94 ashish 1643 
      return result.success
3431 rajveer 1644 
    if result.ex is not None:
94 ashish 1645 
      raise result.ex
483 rajveer 1646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1647 
 
483 rajveer 1648 
  def createOrder(self, order):
94 ashish 1649 
    """
1650 
    Parameters:
483 rajveer 1651 
     - order
94 ashish 1652 
    """
483 rajveer 1653 
    self.send_createOrder(order)
1654 
    return self.recv_createOrder()
94 ashish 1655 
 
483 rajveer 1656 
  def send_createOrder(self, order):
1657 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1658 
    args = createOrder_args()
1659 
    args.order = order
94 ashish 1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
483 rajveer 1664 
  def recv_createOrder(self, ):
94 ashish 1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
483 rajveer 1671 
    result = createOrder_result()
94 ashish 1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
94 ashish 1675 
      return result.success
3431 rajveer 1676 
    if result.ex is not None:
94 ashish 1677 
      raise result.ex
483 rajveer 1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1679 
 
483 rajveer 1680 
  def getOrder(self, id):
94 ashish 1681 
    """
1682 
    Parameters:
483 rajveer 1683 
     - id
94 ashish 1684 
    """
483 rajveer 1685 
    self.send_getOrder(id)
1686 
    return self.recv_getOrder()
94 ashish 1687 
 
483 rajveer 1688 
  def send_getOrder(self, id):
1689 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1690 
    args = getOrder_args()
1691 
    args.id = id
94 ashish 1692 
    args.write(self._oprot)
1693 
    self._oprot.writeMessageEnd()
1694 
    self._oprot.trans.flush()
1695 
 
483 rajveer 1696 
  def recv_getOrder(self, ):
94 ashish 1697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1698 
    if mtype == TMessageType.EXCEPTION:
1699 
      x = TApplicationException()
1700 
      x.read(self._iprot)
1701 
      self._iprot.readMessageEnd()
1702 
      raise x
483 rajveer 1703 
    result = getOrder_result()
94 ashish 1704 
    result.read(self._iprot)
1705 
    self._iprot.readMessageEnd()
3431 rajveer 1706 
    if result.success is not None:
94 ashish 1707 
      return result.success
3431 rajveer 1708 
    if result.ex is not None:
94 ashish 1709 
      raise result.ex
483 rajveer 1710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1711 
 
483 rajveer 1712 
  def getLineItemsForOrder(self, orderId):
94 ashish 1713 
    """
1714 
    Parameters:
483 rajveer 1715 
     - orderId
94 ashish 1716 
    """
483 rajveer 1717 
    self.send_getLineItemsForOrder(orderId)
1718 
    return self.recv_getLineItemsForOrder()
94 ashish 1719 
 
483 rajveer 1720 
  def send_getLineItemsForOrder(self, orderId):
1721 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1722 
    args = getLineItemsForOrder_args()
1723 
    args.orderId = orderId
94 ashish 1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
483 rajveer 1728 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
483 rajveer 1735 
    result = getLineItemsForOrder_result()
94 ashish 1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
3431 rajveer 1738 
    if result.success is not None:
94 ashish 1739 
      return result.success
3431 rajveer 1740 
    if result.ex is not None:
94 ashish 1741 
      raise result.ex
483 rajveer 1742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1743 
 
1528 ankur.sing 1744 
  def getOrderForCustomer(self, orderId, customerId):
1745 
    """
1746 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1747 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1748 
 
1528 ankur.sing 1749 
    Parameters:
1750 
     - orderId
1751 
     - customerId
1752 
    """
1753 
    self.send_getOrderForCustomer(orderId, customerId)
1754 
    return self.recv_getOrderForCustomer()
1755 
 
1756 
  def send_getOrderForCustomer(self, orderId, customerId):
1757 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1758 
    args = getOrderForCustomer_args()
1759 
    args.orderId = orderId
1760 
    args.customerId = customerId
1761 
    args.write(self._oprot)
1762 
    self._oprot.writeMessageEnd()
1763 
    self._oprot.trans.flush()
1764 
 
1765 
  def recv_getOrderForCustomer(self, ):
1766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1767 
    if mtype == TMessageType.EXCEPTION:
1768 
      x = TApplicationException()
1769 
      x.read(self._iprot)
1770 
      self._iprot.readMessageEnd()
1771 
      raise x
1772 
    result = getOrderForCustomer_result()
1773 
    result.read(self._iprot)
1774 
    self._iprot.readMessageEnd()
3431 rajveer 1775 
    if result.success is not None:
1528 ankur.sing 1776 
      return result.success
3431 rajveer 1777 
    if result.ex is not None:
1528 ankur.sing 1778 
      raise result.ex
1779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1780 
 
4444 rajveer 1781 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1782 
    """
1783 
    Parameters:
4394 rajveer 1784 
     - type
4444 rajveer 1785 
     - warehouseId
4394 rajveer 1786 
     - status
1787 
     - timestamp
3064 chandransh 1788 
    """
4444 rajveer 1789 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1790 
    return self.recv_getAlerts()
1791 
 
4444 rajveer 1792 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1793 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1794 
    args = getAlerts_args()
4394 rajveer 1795 
    args.type = type
4444 rajveer 1796 
    args.warehouseId = warehouseId
4394 rajveer 1797 
    args.status = status
1798 
    args.timestamp = timestamp
3064 chandransh 1799 
    args.write(self._oprot)
1800 
    self._oprot.writeMessageEnd()
1801 
    self._oprot.trans.flush()
1802 
 
1803 
  def recv_getAlerts(self, ):
1804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1805 
    if mtype == TMessageType.EXCEPTION:
1806 
      x = TApplicationException()
1807 
      x.read(self._iprot)
1808 
      self._iprot.readMessageEnd()
1809 
      raise x
1810 
    result = getAlerts_result()
1811 
    result.read(self._iprot)
1812 
    self._iprot.readMessageEnd()
3431 rajveer 1813 
    if result.success is not None:
3064 chandransh 1814 
      return result.success
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1816 
 
4444 rajveer 1817 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1818 
    """
1819 
    Parameters:
1820 
     - type
4444 rajveer 1821 
     - warehouseId
4394 rajveer 1822 
     - description
3064 chandransh 1823 
    """
4444 rajveer 1824 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1825 
    self.recv_addAlert()
3064 chandransh 1826 
 
4444 rajveer 1827 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1828 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1829 
    args = addAlert_args()
3064 chandransh 1830 
    args.type = type
4444 rajveer 1831 
    args.warehouseId = warehouseId
4394 rajveer 1832 
    args.description = description
3064 chandransh 1833 
    args.write(self._oprot)
1834 
    self._oprot.writeMessageEnd()
1835 
    self._oprot.trans.flush()
1836 
 
4394 rajveer 1837 
  def recv_addAlert(self, ):
3064 chandransh 1838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1839 
    if mtype == TMessageType.EXCEPTION:
1840 
      x = TApplicationException()
1841 
      x.read(self._iprot)
1842 
      self._iprot.readMessageEnd()
1843 
      raise x
4394 rajveer 1844 
    result = addAlert_result()
3064 chandransh 1845 
    result.read(self._iprot)
1846 
    self._iprot.readMessageEnd()
1847 
    return
1848 
 
4444 rajveer 1849 
  def markAlertsAsSeen(self, warehouseId):
1850 
    """
1851 
    Parameters:
1852 
     - warehouseId
1853 
    """
1854 
    self.send_markAlertsAsSeen(warehouseId)
1855 
    self.recv_markAlertsAsSeen()
1856 
 
1857 
  def send_markAlertsAsSeen(self, warehouseId):
1858 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1859 
    args = markAlertsAsSeen_args()
1860 
    args.warehouseId = warehouseId
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_markAlertsAsSeen(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = markAlertsAsSeen_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
1875 
    return
1876 
 
3064 chandransh 1877 
  def getValidOrderCount(self, ):
1878 
    """
1879 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1880 
    """
1881 
    self.send_getValidOrderCount()
1882 
    return self.recv_getValidOrderCount()
1883 
 
1884 
  def send_getValidOrderCount(self, ):
1885 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1886 
    args = getValidOrderCount_args()
1887 
    args.write(self._oprot)
1888 
    self._oprot.writeMessageEnd()
1889 
    self._oprot.trans.flush()
1890 
 
1891 
  def recv_getValidOrderCount(self, ):
1892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1893 
    if mtype == TMessageType.EXCEPTION:
1894 
      x = TApplicationException()
1895 
      x.read(self._iprot)
1896 
      self._iprot.readMessageEnd()
1897 
      raise x
1898 
    result = getValidOrderCount_result()
1899 
    result.read(self._iprot)
1900 
    self._iprot.readMessageEnd()
3431 rajveer 1901 
    if result.success is not None:
3064 chandransh 1902 
      return result.success
1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1904 
 
1905 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1906 
    """
1907 
    Returns the number of distinct customers who have done successful transactions
1908 
    """
1909 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1910 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1911 
 
1912 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1913 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1914 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
1919 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
1926 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
3064 chandransh 1930 
      return result.success
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1932 
 
1933 
  def getValidOrdersAmountRange(self, ):
1934 
    """
1935 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1936 
    List contains two values, first minimum amount and second maximum amount.
1937 
    """
1938 
    self.send_getValidOrdersAmountRange()
1939 
    return self.recv_getValidOrdersAmountRange()
1940 
 
1941 
  def send_getValidOrdersAmountRange(self, ):
1942 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1943 
    args = getValidOrdersAmountRange_args()
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_getValidOrdersAmountRange(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = getValidOrdersAmountRange_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
3431 rajveer 1958 
    if result.success is not None:
3064 chandransh 1959 
      return result.success
1960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1961 
 
1962 
  def getValidOrders(self, limit):
1963 
    """
1964 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1965 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1966 
 
3064 chandransh 1967 
    Parameters:
1968 
     - limit
1969 
    """
1970 
    self.send_getValidOrders(limit)
1971 
    return self.recv_getValidOrders()
1972 
 
1973 
  def send_getValidOrders(self, limit):
1974 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1975 
    args = getValidOrders_args()
1976 
    args.limit = limit
1977 
    args.write(self._oprot)
1978 
    self._oprot.writeMessageEnd()
1979 
    self._oprot.trans.flush()
1980 
 
1981 
  def recv_getValidOrders(self, ):
1982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1983 
    if mtype == TMessageType.EXCEPTION:
1984 
      x = TApplicationException()
1985 
      x.read(self._iprot)
1986 
      self._iprot.readMessageEnd()
1987 
      raise x
1988 
    result = getValidOrders_result()
1989 
    result.read(self._iprot)
1990 
    self._iprot.readMessageEnd()
3431 rajveer 1991 
    if result.success is not None:
3064 chandransh 1992 
      return result.success
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1994 
 
1220 chandransh 1995 
  def batchOrders(self, warehouseId):
1996 
    """
1997 
    Create a batch of all the pending orders for the given warehouse.
1998 
    The returned list is orderd by created_timestamp.
1999 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2000 
 
1220 chandransh 2001 
    Parameters:
2002 
     - warehouseId
2003 
    """
2004 
    self.send_batchOrders(warehouseId)
2005 
    return self.recv_batchOrders()
2006 
 
2007 
  def send_batchOrders(self, warehouseId):
2008 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2009 
    args = batchOrders_args()
2010 
    args.warehouseId = warehouseId
2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
2015 
  def recv_batchOrders(self, ):
2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
2022 
    result = batchOrders_result()
2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
3431 rajveer 2025 
    if result.success is not None:
1220 chandransh 2026 
      return result.success
3431 rajveer 2027 
    if result.ex is not None:
1220 chandransh 2028 
      raise result.ex
2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2030 
 
1208 chandransh 2031 
  def markOrderAsOutOfStock(self, orderId):
2032 
    """
2033 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2034 
 
1208 chandransh 2035 
    Parameters:
2036 
     - orderId
2037 
    """
2038 
    self.send_markOrderAsOutOfStock(orderId)
2039 
    return self.recv_markOrderAsOutOfStock()
2040 
 
2041 
  def send_markOrderAsOutOfStock(self, orderId):
2042 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2043 
    args = markOrderAsOutOfStock_args()
2044 
    args.orderId = orderId
2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
2049 
  def recv_markOrderAsOutOfStock(self, ):
2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
2056 
    result = markOrderAsOutOfStock_result()
2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.success is not None:
1208 chandransh 2060 
      return result.success
3431 rajveer 2061 
    if result.ex is not None:
1208 chandransh 2062 
      raise result.ex
2063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2064 
 
3064 chandransh 2065 
  def verifyOrder(self, orderId):
759 chandransh 2066 
    """
3064 chandransh 2067 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2068 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2069 
    used for all other orders as well.
2070 
    Throws an exception if no such order exists.
3431 rajveer 2071 
 
759 chandransh 2072 
    Parameters:
3064 chandransh 2073 
     - orderId
759 chandransh 2074 
    """
3064 chandransh 2075 
    self.send_verifyOrder(orderId)
2076 
    return self.recv_verifyOrder()
759 chandransh 2077 
 
3064 chandransh 2078 
  def send_verifyOrder(self, orderId):
2079 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2080 
    args = verifyOrder_args()
2081 
    args.orderId = orderId
759 chandransh 2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
3064 chandransh 2086 
  def recv_verifyOrder(self, ):
759 chandransh 2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
3064 chandransh 2093 
    result = verifyOrder_result()
759 chandransh 2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
3431 rajveer 2096 
    if result.success is not None:
759 chandransh 2097 
      return result.success
3431 rajveer 2098 
    if result.ex is not None:
759 chandransh 2099 
      raise result.ex
3064 chandransh 2100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2101 
 
3064 chandransh 2102 
  def acceptOrder(self, orderId):
1113 chandransh 2103 
    """
3064 chandransh 2104 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2105 
    given order is not a COD order, it also captures the payment if the same has
2106 
    not been captured.
2107 
    Throws an exception if no such order exists.
3431 rajveer 2108 
 
1113 chandransh 2109 
    Parameters:
3064 chandransh 2110 
     - orderId
1113 chandransh 2111 
    """
3064 chandransh 2112 
    self.send_acceptOrder(orderId)
2113 
    return self.recv_acceptOrder()
1113 chandransh 2114 
 
3064 chandransh 2115 
  def send_acceptOrder(self, orderId):
2116 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2117 
    args = acceptOrder_args()
2118 
    args.orderId = orderId
1113 chandransh 2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
3064 chandransh 2123 
  def recv_acceptOrder(self, ):
1113 chandransh 2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
3064 chandransh 2130 
    result = acceptOrder_result()
1113 chandransh 2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
3431 rajveer 2133 
    if result.success is not None:
1113 chandransh 2134 
      return result.success
3431 rajveer 2135 
    if result.ex is not None:
1113 chandransh 2136 
      raise result.ex
3064 chandransh 2137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2138 
 
4763 rajveer 2139 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2140 
    """
3064 chandransh 2141 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2142 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2143 
    the IMEI no. if a -1 is supplied.
2144 
    Also, it generates an invoice number for the order, marks the order as
2145 
    BILLED and sets the billing timestamp.
2146 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2147 
 
1135 chandransh 2148 
    Parameters:
3064 chandransh 2149 
     - orderId
2150 
     - invoice_number
4658 mandeep.dh 2151 
     - serialNumber
4283 anupam.sin 2152 
     - itemNumber
3064 chandransh 2153 
     - billed_by
4264 rajveer 2154 
     - jacketNumber
4283 anupam.sin 2155 
     - billingType
2156 
     - vendorId
4763 rajveer 2157 
     - authorize
1135 chandransh 2158 
    """
4763 rajveer 2159 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2160 
    return self.recv_addBillingDetails()
1135 chandransh 2161 
 
4763 rajveer 2162 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2163 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2164 
    args = addBillingDetails_args()
2165 
    args.orderId = orderId
2166 
    args.invoice_number = invoice_number
4658 mandeep.dh 2167 
    args.serialNumber = serialNumber
4283 anupam.sin 2168 
    args.itemNumber = itemNumber
3064 chandransh 2169 
    args.billed_by = billed_by
4264 rajveer 2170 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2171 
    args.billingType = billingType
2172 
    args.vendorId = vendorId
4763 rajveer 2173 
    args.authorize = authorize
1135 chandransh 2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
3064 chandransh 2178 
  def recv_addBillingDetails(self, ):
1135 chandransh 2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
3064 chandransh 2185 
    result = addBillingDetails_result()
1135 chandransh 2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
3431 rajveer 2188 
    if result.success is not None:
3064 chandransh 2189 
      return result.success
3431 rajveer 2190 
    if result.ex is not None:
1135 chandransh 2191 
      raise result.ex
3064 chandransh 2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2193 
 
4763 rajveer 2194 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2195 
    """
2196 
    Add the invoice number to the order.
2197 
 
2198 
    Parameters:
2199 
     - orderId
2200 
     - invoiceNumber
4763 rajveer 2201 
     - color
4579 rajveer 2202 
    """
4763 rajveer 2203 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2204 
    self.recv_addInvoiceNumber()
2205 
 
4763 rajveer 2206 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2207 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2208 
    args = addInvoiceNumber_args()
2209 
    args.orderId = orderId
2210 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2211 
    args.color = color
4579 rajveer 2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
2216 
  def recv_addInvoiceNumber(self, ):
2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
2223 
    result = addInvoiceNumber_result()
2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
2226 
    if result.ex is not None:
2227 
      raise result.ex
2228 
    return
2229 
 
3064 chandransh 2230 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2231 
    """
3064 chandransh 2232 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2233 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2234 
 
1408 ankur.sing 2235 
    Parameters:
3064 chandransh 2236 
     - warehouseId
1408 ankur.sing 2237 
     - providerId
3064 chandransh 2238 
     - cod
1408 ankur.sing 2239 
    """
3064 chandransh 2240 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2241 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2242 
 
3064 chandransh 2243 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2244 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2245 
    args = markOrdersAsManifested_args()
2246 
    args.warehouseId = warehouseId
1408 ankur.sing 2247 
    args.providerId = providerId
3064 chandransh 2248 
    args.cod = cod
1408 ankur.sing 2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
3064 chandransh 2253 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
3064 chandransh 2260 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
3431 rajveer 2263 
    if result.success is not None:
1408 ankur.sing 2264 
      return result.success
3431 rajveer 2265 
    if result.ex is not None:
3064 chandransh 2266 
      raise result.ex
2267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2268 
 
4410 rajveer 2269 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2270 
    """
2271 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2272 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2273 
 
2274 
    Parameters:
2275 
     - warehouseId
2276 
     - providerId
2277 
     - cod
2278 
    """
2279 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2280 
    return self.recv_markOrdersAsShippedFromWarehouse()
2281 
 
2282 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2283 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2284 
    args = markOrdersAsShippedFromWarehouse_args()
2285 
    args.warehouseId = warehouseId
2286 
    args.providerId = providerId
2287 
    args.cod = cod
2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = markOrdersAsShippedFromWarehouse_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
2302 
    if result.success is not None:
2303 
      return result.success
2304 
    if result.ex is not None:
2305 
      raise result.ex
2306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2307 
 
3064 chandransh 2308 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2309 
    """
3064 chandransh 2310 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2311 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2312 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2313 
 
94 ashish 2314 
    Parameters:
3064 chandransh 2315 
     - providerId
2316 
     - pickupDetails
304 ashish 2317 
    """
3064 chandransh 2318 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2319 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2320 
 
3064 chandransh 2321 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2322 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2323 
    args = markOrdersAsPickedUp_args()
2324 
    args.providerId = providerId
2325 
    args.pickupDetails = pickupDetails
304 ashish 2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
3064 chandransh 2330 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
3064 chandransh 2337 
    result = markOrdersAsPickedUp_result()
304 ashish 2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
304 ashish 2341 
      return result.success
3431 rajveer 2342 
    if result.ex is not None:
3064 chandransh 2343 
      raise result.ex
2344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2345 
 
3064 chandransh 2346 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2347 
    """
3064 chandransh 2348 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2349 
    the name of the receiver.
2350 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2351 
 
304 ashish 2352 
    Parameters:
3064 chandransh 2353 
     - providerId
2354 
     - deliveredOrders
304 ashish 2355 
    """
3064 chandransh 2356 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2357 
    self.recv_markOrdersAsDelivered()
304 ashish 2358 
 
3064 chandransh 2359 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2360 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2361 
    args = markOrdersAsDelivered_args()
2362 
    args.providerId = providerId
2363 
    args.deliveredOrders = deliveredOrders
304 ashish 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
3064 chandransh 2368 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
3064 chandransh 2375 
    result = markOrdersAsDelivered_result()
304 ashish 2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
3431 rajveer 2378 
    if result.ex is not None:
3064 chandransh 2379 
      raise result.ex
304 ashish 2380 
    return
2381 
 
3064 chandransh 2382 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2383 
    """
3064 chandransh 2384 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2385 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2386 
 
3064 chandransh 2387 
    Parameters:
2388 
     - providerId
2389 
     - returnedOrders
1596 ankur.sing 2390 
    """
3064 chandransh 2391 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2392 
    self.recv_markOrdersAsFailed()
304 ashish 2393 
 
3064 chandransh 2394 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2395 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2396 
    args = markOrdersAsFailed_args()
2397 
    args.providerId = providerId
2398 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
3064 chandransh 2403 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
3064 chandransh 2410 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
3431 rajveer 2413 
    if result.ex is not None:
3064 chandransh 2414 
      raise result.ex
2415 
    return
1596 ankur.sing 2416 
 
3064 chandransh 2417 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2418 
    """
3064 chandransh 2419 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2420 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2421 
 
3064 chandransh 2422 
    Parameters:
2423 
     - providerId
2424 
     - undeliveredOrders
1627 ankur.sing 2425 
    """
3064 chandransh 2426 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2427 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2428 
 
3064 chandransh 2429 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2430 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2431 
    args = updateNonDeliveryReason_args()
2432 
    args.providerId = providerId
2433 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2434 
    args.write(self._oprot)
2435 
    self._oprot.writeMessageEnd()
2436 
    self._oprot.trans.flush()
2437 
 
3064 chandransh 2438 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2440 
    if mtype == TMessageType.EXCEPTION:
2441 
      x = TApplicationException()
2442 
      x.read(self._iprot)
2443 
      self._iprot.readMessageEnd()
2444 
      raise x
3064 chandransh 2445 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2446 
    result.read(self._iprot)
2447 
    self._iprot.readMessageEnd()
4581 phani.kuma 2448 
    if result.success is not None:
2449 
      return result.success
3431 rajveer 2450 
    if result.ex is not None:
3064 chandransh 2451 
      raise result.ex
4581 phani.kuma 2452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2453 
 
3064 chandransh 2454 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2455 
    """
3064 chandransh 2456 
    Returns the list of orders whose delivery time has passed but have not been
2457 
    delivered yet for the given provider and warehouse. To get a complete list of
2458 
    undelivered orders, pass them as -1.
2459 
    Returns an empty list if no such orders exist.
3431 rajveer 2460 
 
1886 ankur.sing 2461 
    Parameters:
3064 chandransh 2462 
     - providerId
2463 
     - warehouseId
1886 ankur.sing 2464 
    """
3064 chandransh 2465 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2466 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2467 
 
3064 chandransh 2468 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2469 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2470 
    args = getUndeliveredOrders_args()
2471 
    args.providerId = providerId
2472 
    args.warehouseId = warehouseId
1886 ankur.sing 2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
3064 chandransh 2477 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
3064 chandransh 2484 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
3431 rajveer 2487 
    if result.success is not None:
1886 ankur.sing 2488 
      return result.success
3064 chandransh 2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2490 
 
4783 phani.kuma 2491 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2492 
    """
2493 
    Returns the list of orders whose expected delivery date has passed but have not been
2494 
    delivered yet.
2495 
    Returns an empty list if no such orders exist.
2496 
    """
2497 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2498 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2499 
 
2500 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2501 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2502 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.success is not None:
2518 
      return result.success
2519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2520 
 
2536 chandransh 2521 
  def toggleDOAFlag(self, orderId):
2522 
    """
2523 
    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.
2524 
    Returns the final flag status.
2525 
    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 2526 
 
2536 chandransh 2527 
    Parameters:
2528 
     - orderId
2529 
    """
2530 
    self.send_toggleDOAFlag(orderId)
2531 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2532 
 
2536 chandransh 2533 
  def send_toggleDOAFlag(self, orderId):
2534 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2535 
    args = toggleDOAFlag_args()
2536 
    args.orderId = orderId
2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_toggleDOAFlag(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = toggleDOAFlag_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
3431 rajveer 2551 
    if result.success is not None:
2536 chandransh 2552 
      return result.success
3431 rajveer 2553 
    if result.ex is not None:
2536 chandransh 2554 
      raise result.ex
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2556 
 
4712 rajveer 2557 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2558 
    """
2559 
    Parameters:
2560 
     - orderId
2561 
     - deliveryTimestamp
2562 
     - receiver
2563 
    """
2564 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2565 
    self.recv_markOrderAsDelivered()
2566 
 
2567 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2568 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2569 
    args = markOrderAsDelivered_args()
2570 
    args.orderId = orderId
2571 
    args.deliveryTimestamp = deliveryTimestamp
2572 
    args.receiver = receiver
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_markOrderAsDelivered(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = markOrderAsDelivered_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.ex is not None:
2588 
      raise result.ex
2589 
    return
2590 
 
4454 rajveer 2591 
  def markOrderDoaRequestReceived(self, orderId):
2592 
    """
2593 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2594 
 
2595 
    Parameters:
2596 
     - orderId
2597 
    """
2598 
    self.send_markOrderDoaRequestReceived(orderId)
2599 
    return self.recv_markOrderDoaRequestReceived()
2600 
 
2601 
  def send_markOrderDoaRequestReceived(self, orderId):
2602 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2603 
    args = markOrderDoaRequestReceived_args()
2604 
    args.orderId = orderId
2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_markOrderDoaRequestReceived(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = markOrderDoaRequestReceived_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    if result.success is not None:
2620 
      return result.success
2621 
    if result.ex is not None:
2622 
      raise result.ex
2623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2624 
 
2625 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2626 
    """
2627 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2628 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2629 
 
2630 
    Parameters:
2631 
     - orderId
2632 
     - isAuthorized
2633 
    """
2634 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2635 
    return self.recv_markOrderDoaRequestAuthorized()
2636 
 
2637 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2638 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2639 
    args = markOrderDoaRequestAuthorized_args()
2640 
    args.orderId = orderId
2641 
    args.isAuthorized = isAuthorized
2642 
    args.write(self._oprot)
2643 
    self._oprot.writeMessageEnd()
2644 
    self._oprot.trans.flush()
2645 
 
2646 
  def recv_markOrderDoaRequestAuthorized(self, ):
2647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2648 
    if mtype == TMessageType.EXCEPTION:
2649 
      x = TApplicationException()
2650 
      x.read(self._iprot)
2651 
      self._iprot.readMessageEnd()
2652 
      raise x
2653 
    result = markOrderDoaRequestAuthorized_result()
2654 
    result.read(self._iprot)
2655 
    self._iprot.readMessageEnd()
2656 
    if result.success is not None:
2657 
      return result.success
2658 
    if result.ex is not None:
2659 
      raise result.ex
2660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2661 
 
4488 rajveer 2662 
  def markOrderReturnRequestReceived(self, orderId):
2663 
    """
2664 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2665 
 
2666 
    Parameters:
2667 
     - orderId
2668 
    """
2669 
    self.send_markOrderReturnRequestReceived(orderId)
2670 
    return self.recv_markOrderReturnRequestReceived()
2671 
 
2672 
  def send_markOrderReturnRequestReceived(self, orderId):
2673 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2674 
    args = markOrderReturnRequestReceived_args()
2675 
    args.orderId = orderId
2676 
    args.write(self._oprot)
2677 
    self._oprot.writeMessageEnd()
2678 
    self._oprot.trans.flush()
2679 
 
2680 
  def recv_markOrderReturnRequestReceived(self, ):
2681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2682 
    if mtype == TMessageType.EXCEPTION:
2683 
      x = TApplicationException()
2684 
      x.read(self._iprot)
2685 
      self._iprot.readMessageEnd()
2686 
      raise x
2687 
    result = markOrderReturnRequestReceived_result()
2688 
    result.read(self._iprot)
2689 
    self._iprot.readMessageEnd()
2690 
    if result.success is not None:
2691 
      return result.success
2692 
    if result.ex is not None:
2693 
      raise result.ex
2694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2695 
 
2696 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2697 
    """
2698 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2699 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2700 
 
2701 
    Parameters:
2702 
     - orderId
2703 
     - isAuthorized
2704 
    """
2705 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2706 
    return self.recv_markOrderReturnRequestAuthorized()
2707 
 
2708 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2709 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2710 
    args = markOrderReturnRequestAuthorized_args()
2711 
    args.orderId = orderId
2712 
    args.isAuthorized = isAuthorized
2713 
    args.write(self._oprot)
2714 
    self._oprot.writeMessageEnd()
2715 
    self._oprot.trans.flush()
2716 
 
2717 
  def recv_markOrderReturnRequestAuthorized(self, ):
2718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2719 
    if mtype == TMessageType.EXCEPTION:
2720 
      x = TApplicationException()
2721 
      x.read(self._iprot)
2722 
      self._iprot.readMessageEnd()
2723 
      raise x
2724 
    result = markOrderReturnRequestAuthorized_result()
2725 
    result.read(self._iprot)
2726 
    self._iprot.readMessageEnd()
2727 
    if result.success is not None:
2728 
      return result.success
2729 
    if result.ex is not None:
2730 
      raise result.ex
2731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2732 
 
4579 rajveer 2733 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2734 
    """
2735 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2736 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2737 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2738 
    For any other status, it returns false.
2739 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2740 
 
2536 chandransh 2741 
    Parameters:
2742 
     - orderId
4579 rajveer 2743 
     - providerId
2536 chandransh 2744 
    """
4579 rajveer 2745 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2746 
    return self.recv_requestPickupNumber()
2747 
 
4579 rajveer 2748 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2749 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2750 
    args = requestPickupNumber_args()
2751 
    args.orderId = orderId
4579 rajveer 2752 
    args.providerId = providerId
2536 chandransh 2753 
    args.write(self._oprot)
2754 
    self._oprot.writeMessageEnd()
2755 
    self._oprot.trans.flush()
2756 
 
2757 
  def recv_requestPickupNumber(self, ):
2758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2759 
    if mtype == TMessageType.EXCEPTION:
2760 
      x = TApplicationException()
2761 
      x.read(self._iprot)
2762 
      self._iprot.readMessageEnd()
2763 
      raise x
2764 
    result = requestPickupNumber_result()
2765 
    result.read(self._iprot)
2766 
    self._iprot.readMessageEnd()
3431 rajveer 2767 
    if result.success is not None:
2536 chandransh 2768 
      return result.success
3431 rajveer 2769 
    if result.ex is not None:
2536 chandransh 2770 
      raise result.ex
2771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2772 
 
4602 rajveer 2773 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2774 
    """
4452 rajveer 2775 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2776 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2777 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2778 
    	3. Returns true
2591 chandransh 2779 
    If the order is in any other status, it returns false.
2536 chandransh 2780 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2781 
 
2536 chandransh 2782 
    Parameters:
2783 
     - orderId
2784 
     - pickupNumber
4602 rajveer 2785 
     - providerId
2536 chandransh 2786 
    """
4602 rajveer 2787 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2788 
    return self.recv_authorizePickup()
2789 
 
4602 rajveer 2790 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2791 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2792 
    args = authorizePickup_args()
2793 
    args.orderId = orderId
2794 
    args.pickupNumber = pickupNumber
4602 rajveer 2795 
    args.providerId = providerId
2536 chandransh 2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
2800 
  def recv_authorizePickup(self, ):
2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
2807 
    result = authorizePickup_result()
2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
3431 rajveer 2810 
    if result.success is not None:
2536 chandransh 2811 
      return result.success
3431 rajveer 2812 
    if result.ex is not None:
2536 chandransh 2813 
      raise result.ex
2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2815 
 
2764 chandransh 2816 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2817 
    """
2818 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2819 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2820 
 
2764 chandransh 2821 
    Parameters:
2822 
     - providerId
2823 
     - pickupDetails
2824 
    """
2825 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2826 
    return self.recv_markDoasAsPickedUp()
2827 
 
2828 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2829 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2830 
    args = markDoasAsPickedUp_args()
2831 
    args.providerId = providerId
2832 
    args.pickupDetails = pickupDetails
2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
2837 
  def recv_markDoasAsPickedUp(self, ):
2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
2844 
    result = markDoasAsPickedUp_result()
2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
3431 rajveer 2847 
    if result.success is not None:
2764 chandransh 2848 
      return result.success
2849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2850 
 
4741 phani.kuma 2851 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2852 
    """
2853 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2854 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2855 
 
2856 
    Parameters:
2857 
     - providerId
2858 
     - pickupDetails
2859 
    """
2860 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2861 
    return self.recv_markReturnOrdersAsPickedUp()
2862 
 
2863 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2864 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2865 
    args = markReturnOrdersAsPickedUp_args()
2866 
    args.providerId = providerId
2867 
    args.pickupDetails = pickupDetails
2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
2872 
  def recv_markReturnOrdersAsPickedUp(self, ):
2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
2879 
    result = markReturnOrdersAsPickedUp_result()
2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
2882 
    if result.success is not None:
2883 
      return result.success
2884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2885 
 
4479 rajveer 2886 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2887 
    """
4452 rajveer 2888 
    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 2889 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2890 
    If the order is in any other state, it returns false.
2891 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2892 
 
2591 chandransh 2893 
    Parameters:
2894 
     - orderId
4479 rajveer 2895 
     - receiveCondition
2591 chandransh 2896 
    """
4479 rajveer 2897 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2898 
    return self.recv_receiveReturn()
2536 chandransh 2899 
 
4479 rajveer 2900 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2901 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2902 
    args = receiveReturn_args()
2591 chandransh 2903 
    args.orderId = orderId
4479 rajveer 2904 
    args.receiveCondition = receiveCondition
2591 chandransh 2905 
    args.write(self._oprot)
2906 
    self._oprot.writeMessageEnd()
2907 
    self._oprot.trans.flush()
2908 
 
2616 chandransh 2909 
  def recv_receiveReturn(self, ):
2591 chandransh 2910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2911 
    if mtype == TMessageType.EXCEPTION:
2912 
      x = TApplicationException()
2913 
      x.read(self._iprot)
2914 
      self._iprot.readMessageEnd()
2915 
      raise x
2616 chandransh 2916 
    result = receiveReturn_result()
2591 chandransh 2917 
    result.read(self._iprot)
2918 
    self._iprot.readMessageEnd()
3431 rajveer 2919 
    if result.success is not None:
2591 chandransh 2920 
      return result.success
3431 rajveer 2921 
    if result.ex is not None:
2591 chandransh 2922 
      raise result.ex
2616 chandransh 2923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2924 
 
2925 
  def validateDoa(self, orderId, isValid):
2926 
    """
4452 rajveer 2927 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2928 
    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 2929 
    If the order is in any other state, it returns false.
2930 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2931 
 
2591 chandransh 2932 
    Parameters:
2933 
     - orderId
2934 
     - isValid
2935 
    """
2936 
    self.send_validateDoa(orderId, isValid)
2937 
    return self.recv_validateDoa()
2938 
 
2939 
  def send_validateDoa(self, orderId, isValid):
2940 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2941 
    args = validateDoa_args()
2942 
    args.orderId = orderId
2943 
    args.isValid = isValid
2944 
    args.write(self._oprot)
2945 
    self._oprot.writeMessageEnd()
2946 
    self._oprot.trans.flush()
2947 
 
2948 
  def recv_validateDoa(self, ):
2949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2950 
    if mtype == TMessageType.EXCEPTION:
2951 
      x = TApplicationException()
2952 
      x.read(self._iprot)
2953 
      self._iprot.readMessageEnd()
2954 
      raise x
2955 
    result = validateDoa_result()
2956 
    result.read(self._iprot)
2957 
    self._iprot.readMessageEnd()
3431 rajveer 2958 
    if result.success is not None:
2591 chandransh 2959 
      return result.success
3431 rajveer 2960 
    if result.ex is not None:
2591 chandransh 2961 
      raise result.ex
2962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2963 
 
4495 rajveer 2964 
  def validateReturnProduct(self, orderId, isUsable):
2965 
    """
2966 
    Parameters:
2967 
     - orderId
2968 
     - isUsable
2969 
    """
2970 
    self.send_validateReturnProduct(orderId, isUsable)
2971 
    return self.recv_validateReturnProduct()
2972 
 
2973 
  def send_validateReturnProduct(self, orderId, isUsable):
2974 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2975 
    args = validateReturnProduct_args()
2976 
    args.orderId = orderId
2977 
    args.isUsable = isUsable
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_validateReturnProduct(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = validateReturnProduct_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
2992 
    if result.success is not None:
2993 
      return result.success
2994 
    if result.ex is not None:
2995 
      raise result.ex
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2997 
 
2616 chandransh 2998 
  def reshipOrder(self, orderId):
2999 
    """
4484 rajveer 3000 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3001 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3002 
    	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 3003 
 
3004 
    If the order is in DOA_CERT_VALID state, it does the following:
3005 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3006 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3007 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3008 
 
2616 chandransh 3009 
    Returns the id of the newly created order.
3431 rajveer 3010 
 
2616 chandransh 3011 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3012 
 
2616 chandransh 3013 
    Parameters:
3014 
     - orderId
3015 
    """
3016 
    self.send_reshipOrder(orderId)
3017 
    return self.recv_reshipOrder()
2591 chandransh 3018 
 
2616 chandransh 3019 
  def send_reshipOrder(self, orderId):
3020 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3021 
    args = reshipOrder_args()
3022 
    args.orderId = orderId
3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3027 
  def recv_reshipOrder(self, ):
3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3034 
    result = reshipOrder_result()
3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3431 rajveer 3037 
    if result.success is not None:
2616 chandransh 3038 
      return result.success
3431 rajveer 3039 
    if result.ex is not None:
2616 chandransh 3040 
      raise result.ex
3041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3042 
 
3226 chandransh 3043 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3044 
    """
4484 rajveer 3045 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3046 
    	1. Creates a refund request for batch processing.
3047 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3048 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3049 
 
2616 chandransh 3050 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3051 
    	1. Creates a refund request for batch processing.
3226 chandransh 3052 
    	2. Cancels the reservation of the item in the warehouse.
3053 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3054 
 
3226 chandransh 3055 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3056 
    	1. Cancels the reservation of the item in the warehouse.
3057 
    	2. Marks the current order as CANCELED.
3058 
 
3059 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3060 
 
2616 chandransh 3061 
    Returns True if it is successful, False otherwise.
3431 rajveer 3062 
 
2616 chandransh 3063 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3064 
 
2616 chandransh 3065 
    Parameters:
3066 
     - orderId
3226 chandransh 3067 
     - refundedBy
3068 
     - reason
2616 chandransh 3069 
    """
3226 chandransh 3070 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3071 
    return self.recv_refundOrder()
3072 
 
3226 chandransh 3073 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3074 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3075 
    args = refundOrder_args()
3076 
    args.orderId = orderId
3226 chandransh 3077 
    args.refundedBy = refundedBy
3078 
    args.reason = reason
2616 chandransh 3079 
    args.write(self._oprot)
3080 
    self._oprot.writeMessageEnd()
3081 
    self._oprot.trans.flush()
3082 
 
3083 
  def recv_refundOrder(self, ):
3084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3085 
    if mtype == TMessageType.EXCEPTION:
3086 
      x = TApplicationException()
3087 
      x.read(self._iprot)
3088 
      self._iprot.readMessageEnd()
3089 
      raise x
3090 
    result = refundOrder_result()
3091 
    result.read(self._iprot)
3092 
    self._iprot.readMessageEnd()
3431 rajveer 3093 
    if result.success is not None:
2616 chandransh 3094 
      return result.success
3431 rajveer 3095 
    if result.ex is not None:
2616 chandransh 3096 
      raise result.ex
3097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3098 
 
2690 chandransh 3099 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3100 
    """
3101 
    Get all return orders created between the from and to dates for the given warehouse.
3102 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3103 
 
2690 chandransh 3104 
    Parameters:
3105 
     - warehouseId
3106 
     - fromDate
3107 
     - toDate
3108 
    """
3109 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3110 
    return self.recv_getReturnOrders()
2616 chandransh 3111 
 
2690 chandransh 3112 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3113 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3114 
    args = getReturnOrders_args()
3115 
    args.warehouseId = warehouseId
3116 
    args.fromDate = fromDate
3117 
    args.toDate = toDate
3118 
    args.write(self._oprot)
3119 
    self._oprot.writeMessageEnd()
3120 
    self._oprot.trans.flush()
3121 
 
3122 
  def recv_getReturnOrders(self, ):
3123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3124 
    if mtype == TMessageType.EXCEPTION:
3125 
      x = TApplicationException()
3126 
      x.read(self._iprot)
3127 
      self._iprot.readMessageEnd()
3128 
      raise x
3129 
    result = getReturnOrders_result()
3130 
    result.read(self._iprot)
3131 
    self._iprot.readMessageEnd()
3431 rajveer 3132 
    if result.success is not None:
2690 chandransh 3133 
      return result.success
3134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3135 
 
2700 chandransh 3136 
  def getReturnOrder(self, id):
3137 
    """
3138 
    Returns the ReturnOrder corresponding to the given id.
3139 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3140 
 
2700 chandransh 3141 
    Parameters:
3142 
     - id
3143 
    """
3144 
    self.send_getReturnOrder(id)
3145 
    return self.recv_getReturnOrder()
3146 
 
3147 
  def send_getReturnOrder(self, id):
3148 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3149 
    args = getReturnOrder_args()
3150 
    args.id = id
3151 
    args.write(self._oprot)
3152 
    self._oprot.writeMessageEnd()
3153 
    self._oprot.trans.flush()
3154 
 
3155 
  def recv_getReturnOrder(self, ):
3156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3157 
    if mtype == TMessageType.EXCEPTION:
3158 
      x = TApplicationException()
3159 
      x.read(self._iprot)
3160 
      self._iprot.readMessageEnd()
3161 
      raise x
3162 
    result = getReturnOrder_result()
3163 
    result.read(self._iprot)
3164 
    self._iprot.readMessageEnd()
3431 rajveer 3165 
    if result.success is not None:
2700 chandransh 3166 
      return result.success
3431 rajveer 3167 
    if result.ex is not None:
2700 chandransh 3168 
      raise result.ex
3169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3170 
 
2690 chandransh 3171 
  def processReturn(self, returnOrderId):
3172 
    """
3173 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3174 
 
2690 chandransh 3175 
    Parameters:
3176 
     - returnOrderId
3177 
    """
3178 
    self.send_processReturn(returnOrderId)
3179 
    self.recv_processReturn()
3180 
 
3181 
  def send_processReturn(self, returnOrderId):
3182 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3183 
    args = processReturn_args()
3184 
    args.returnOrderId = returnOrderId
3185 
    args.write(self._oprot)
3186 
    self._oprot.writeMessageEnd()
3187 
    self._oprot.trans.flush()
3188 
 
3189 
  def recv_processReturn(self, ):
3190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3191 
    if mtype == TMessageType.EXCEPTION:
3192 
      x = TApplicationException()
3193 
      x.read(self._iprot)
3194 
      self._iprot.readMessageEnd()
3195 
      raise x
3196 
    result = processReturn_result()
3197 
    result.read(self._iprot)
3198 
    self._iprot.readMessageEnd()
3431 rajveer 3199 
    if result.ex is not None:
2690 chandransh 3200 
      raise result.ex
3201 
    return
3202 
 
3451 chandransh 3203 
  def updateWeight(self, orderId, weight):
3204 
    """
3205 
    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 3206 
 
3451 chandransh 3207 
    Parameters:
3208 
     - orderId
3209 
     - weight
3210 
    """
3211 
    self.send_updateWeight(orderId, weight)
3212 
    return self.recv_updateWeight()
3213 
 
3214 
  def send_updateWeight(self, orderId, weight):
3215 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3216 
    args = updateWeight_args()
3217 
    args.orderId = orderId
3218 
    args.weight = weight
3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3223 
  def recv_updateWeight(self, ):
3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3230 
    result = updateWeight_result()
3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3233 
    if result.success is not None:
3234 
      return result.success
3235 
    if result.ex is not None:
3236 
      raise result.ex
3237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3238 
 
3469 chandransh 3239 
  def changeItem(self, orderId, itemId):
3240 
    """
3241 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3242 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3243 
 
3469 chandransh 3244 
    Parameters:
3245 
     - orderId
3246 
     - itemId
3247 
    """
3248 
    self.send_changeItem(orderId, itemId)
3249 
    return self.recv_changeItem()
3250 
 
3251 
  def send_changeItem(self, orderId, itemId):
3252 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3253 
    args = changeItem_args()
3254 
    args.orderId = orderId
3255 
    args.itemId = itemId
3256 
    args.write(self._oprot)
3257 
    self._oprot.writeMessageEnd()
3258 
    self._oprot.trans.flush()
3259 
 
3260 
  def recv_changeItem(self, ):
3261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3262 
    if mtype == TMessageType.EXCEPTION:
3263 
      x = TApplicationException()
3264 
      x.read(self._iprot)
3265 
      self._iprot.readMessageEnd()
3266 
      raise x
3267 
    result = changeItem_result()
3268 
    result.read(self._iprot)
3269 
    self._iprot.readMessageEnd()
3270 
    if result.success is not None:
3271 
      return result.success
3272 
    if result.ex is not None:
3273 
      raise result.ex
3274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3275 
 
3276 
  def shiftToWarehouse(self, orderId, warehouseId):
3277 
    """
3278 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3279 
 
3280 
    Parameters:
3281 
     - orderId
3282 
     - warehouseId
3283 
    """
3284 
    self.send_shiftToWarehouse(orderId, warehouseId)
3285 
    return self.recv_shiftToWarehouse()
3286 
 
3287 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3288 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3289 
    args = shiftToWarehouse_args()
3290 
    args.orderId = orderId
3291 
    args.warehouseId = warehouseId
3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_shiftToWarehouse(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = shiftToWarehouse_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    if result.ex is not None:
3309 
      raise result.ex
3310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3311 
 
4647 rajveer 3312 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3313 
    """
3314 
    Adds the given delay reason to the given order.
3986 chandransh 3315 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3316 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3317 
 
3553 chandransh 3318 
    Parameters:
3319 
     - orderId
3320 
     - delayReason
3986 chandransh 3321 
     - furtherDelay
4647 rajveer 3322 
     - delayReasonText
3553 chandransh 3323 
    """
4647 rajveer 3324 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3325 
    return self.recv_addDelayReason()
3326 
 
4647 rajveer 3327 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3328 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3329 
    args = addDelayReason_args()
3330 
    args.orderId = orderId
3331 
    args.delayReason = delayReason
3986 chandransh 3332 
    args.furtherDelay = furtherDelay
4647 rajveer 3333 
    args.delayReasonText = delayReasonText
3553 chandransh 3334 
    args.write(self._oprot)
3335 
    self._oprot.writeMessageEnd()
3336 
    self._oprot.trans.flush()
3337 
 
3338 
  def recv_addDelayReason(self, ):
3339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3340 
    if mtype == TMessageType.EXCEPTION:
3341 
      x = TApplicationException()
3342 
      x.read(self._iprot)
3343 
      self._iprot.readMessageEnd()
3344 
      raise x
3345 
    result = addDelayReason_result()
3346 
    result.read(self._iprot)
3347 
    self._iprot.readMessageEnd()
3348 
    if result.success is not None:
3349 
      return result.success
3350 
    if result.ex is not None:
3351 
      raise result.ex
3352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3353 
 
3956 chandransh 3354 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3355 
    """
3356 
    Marks the COD orders with given AWB nos. as having been processed.
3357 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3358 
 
3956 chandransh 3359 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3360 
    1. There is no order corresponding to an AWB number.
3361 
    2. The captured amount for a payment exceeds the total payment.
3362 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3363 
 
3364 
    Parameters:
3365 
     - collectedAmountMap
3366 
     - xferBy
3367 
     - xferTxnId
3368 
     - xferDate
3369 
    """
3370 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3371 
    return self.recv_reconcileCodCollection()
3372 
 
3373 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3374 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3375 
    args = reconcileCodCollection_args()
3376 
    args.collectedAmountMap = collectedAmountMap
3377 
    args.xferBy = xferBy
3378 
    args.xferTxnId = xferTxnId
3379 
    args.xferDate = xferDate
3380 
    args.write(self._oprot)
3381 
    self._oprot.writeMessageEnd()
3382 
    self._oprot.trans.flush()
3383 
 
3384 
  def recv_reconcileCodCollection(self, ):
3385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3386 
    if mtype == TMessageType.EXCEPTION:
3387 
      x = TApplicationException()
3388 
      x.read(self._iprot)
3389 
      self._iprot.readMessageEnd()
3390 
      raise x
3391 
    result = reconcileCodCollection_result()
3392 
    result.read(self._iprot)
3393 
    self._iprot.readMessageEnd()
3394 
    if result.success is not None:
3395 
      return result.success
3396 
    if result.ex is not None:
3397 
      raise result.ex
3398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3399 
 
4008 mandeep.dh 3400 
  def getTransactionsRequiringExtraProcessing(self, category):
3401 
    """
4065 mandeep.dh 3402 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3403 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3404 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3405 
 
4008 mandeep.dh 3406 
    Parameters:
3407 
     - category
3408 
    """
3409 
    self.send_getTransactionsRequiringExtraProcessing(category)
3410 
    return self.recv_getTransactionsRequiringExtraProcessing()
3411 
 
3412 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3413 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3414 
    args = getTransactionsRequiringExtraProcessing_args()
3415 
    args.category = category
3416 
    args.write(self._oprot)
3417 
    self._oprot.writeMessageEnd()
3418 
    self._oprot.trans.flush()
3419 
 
3420 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3422 
    if mtype == TMessageType.EXCEPTION:
3423 
      x = TApplicationException()
3424 
      x.read(self._iprot)
3425 
      self._iprot.readMessageEnd()
3426 
      raise x
3427 
    result = getTransactionsRequiringExtraProcessing_result()
3428 
    result.read(self._iprot)
3429 
    self._iprot.readMessageEnd()
3430 
    if result.success is not None:
3431 
      return result.success
3432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3433 
 
3434 
  def markTransactionAsProcessed(self, transactionId, category):
3435 
    """
3436 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3437 
    It essentially deletes the transaction id record for a particular
3438 
    processing type category (if present) from DB.
3439 
    This is currently used by CRM application.
4008 mandeep.dh 3440 
 
3441 
    Parameters:
3442 
     - transactionId
3443 
     - category
3444 
    """
3445 
    self.send_markTransactionAsProcessed(transactionId, category)
3446 
    self.recv_markTransactionAsProcessed()
3447 
 
3448 
  def send_markTransactionAsProcessed(self, transactionId, category):
3449 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3450 
    args = markTransactionAsProcessed_args()
3451 
    args.transactionId = transactionId
3452 
    args.category = category
3453 
    args.write(self._oprot)
3454 
    self._oprot.writeMessageEnd()
3455 
    self._oprot.trans.flush()
3456 
 
3457 
  def recv_markTransactionAsProcessed(self, ):
3458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3459 
    if mtype == TMessageType.EXCEPTION:
3460 
      x = TApplicationException()
3461 
      x.read(self._iprot)
3462 
      self._iprot.readMessageEnd()
3463 
      raise x
3464 
    result = markTransactionAsProcessed_result()
3465 
    result.read(self._iprot)
3466 
    self._iprot.readMessageEnd()
3467 
    return
3468 
 
4018 chandransh 3469 
  def getItemWiseRiskyOrdersCount(self, ):
3470 
    """
3471 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3472 
    is defined as one whose shipping date is about to expire.
3473 
    """
3474 
    self.send_getItemWiseRiskyOrdersCount()
3475 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3476 
 
4018 chandransh 3477 
  def send_getItemWiseRiskyOrdersCount(self, ):
3478 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3479 
    args = getItemWiseRiskyOrdersCount_args()
3480 
    args.write(self._oprot)
3481 
    self._oprot.writeMessageEnd()
3482 
    self._oprot.trans.flush()
3483 
 
3484 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3486 
    if mtype == TMessageType.EXCEPTION:
3487 
      x = TApplicationException()
3488 
      x.read(self._iprot)
3489 
      self._iprot.readMessageEnd()
3490 
      raise x
3491 
    result = getItemWiseRiskyOrdersCount_result()
3492 
    result.read(self._iprot)
3493 
    self._iprot.readMessageEnd()
3494 
    if result.success is not None:
3495 
      return result.success
3496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3497 
 
4295 varun.gupt 3498 
  def getOrdersForItemIds(self, itemIds):
3499 
    """
3500 
    Returns a list of all orders which have items with given id
3501 
 
3502 
    Parameters:
3503 
     - itemIds
3504 
    """
3505 
    self.send_getOrdersForItemIds(itemIds)
3506 
    return self.recv_getOrdersForItemIds()
3507 
 
3508 
  def send_getOrdersForItemIds(self, itemIds):
3509 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3510 
    args = getOrdersForItemIds_args()
3511 
    args.itemIds = itemIds
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_getOrdersForItemIds(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = getOrdersForItemIds_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.success is not None:
3527 
      return result.success
3528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3529 
 
4247 rajveer 3530 
  def markOrderCancellationRequestReceived(self, orderId):
3531 
    """
3532 
    Mark order as cancellation request received. If customer sends request of cancellation of
3533 
    a particular order, this method will be called. It will just change status of the order
3534 
    depending on its current status. It also records the previous status, so that we can move
3535 
    back to that status if cancellation request is denied.
4018 chandransh 3536 
 
4247 rajveer 3537 
    Parameters:
3538 
     - orderId
3539 
    """
3540 
    self.send_markOrderCancellationRequestReceived(orderId)
3541 
    self.recv_markOrderCancellationRequestReceived()
3542 
 
3543 
  def send_markOrderCancellationRequestReceived(self, orderId):
3544 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3545 
    args = markOrderCancellationRequestReceived_args()
3546 
    args.orderId = orderId
3547 
    args.write(self._oprot)
3548 
    self._oprot.writeMessageEnd()
3549 
    self._oprot.trans.flush()
3550 
 
3551 
  def recv_markOrderCancellationRequestReceived(self, ):
3552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3553 
    if mtype == TMessageType.EXCEPTION:
3554 
      x = TApplicationException()
3555 
      x.read(self._iprot)
3556 
      self._iprot.readMessageEnd()
3557 
      raise x
3558 
    result = markOrderCancellationRequestReceived_result()
3559 
    result.read(self._iprot)
3560 
    self._iprot.readMessageEnd()
3561 
    if result.ex is not None:
3562 
      raise result.ex
3563 
    return
3564 
 
3565 
  def markOrderCancellationRequestConfirmed(self, orderId):
3566 
    """
3567 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3568 
    cancellation request confirmed. After this OM will be able to cancel the order.
3569 
 
3570 
    Parameters:
3571 
     - orderId
3572 
    """
3573 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3574 
    self.recv_markOrderCancellationRequestConfirmed()
3575 
 
3576 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3577 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3578 
    args = markOrderCancellationRequestConfirmed_args()
3579 
    args.orderId = orderId
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = markOrderCancellationRequestConfirmed_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.ex is not None:
3595 
      raise result.ex
3596 
    return
3597 
 
3598 
  def markOrderCancellationRequestDenied(self, orderId):
3599 
    """
3600 
    If we decide to not to cancel order, we will move the order ro previous status.
3601 
 
3602 
    Parameters:
3603 
     - orderId
3604 
    """
3605 
    self.send_markOrderCancellationRequestDenied(orderId)
3606 
    self.recv_markOrderCancellationRequestDenied()
3607 
 
3608 
  def send_markOrderCancellationRequestDenied(self, orderId):
3609 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3610 
    args = markOrderCancellationRequestDenied_args()
3611 
    args.orderId = orderId
3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_markOrderCancellationRequestDenied(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = markOrderCancellationRequestDenied_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
3626 
    if result.ex is not None:
3627 
      raise result.ex
3628 
    return
3629 
 
4258 rajveer 3630 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3631 
    """
4258 rajveer 3632 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3633 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3634 
 
3635 
    Parameters:
4258 rajveer 3636 
     - transactionId
4247 rajveer 3637 
    """
4258 rajveer 3638 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3639 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3640 
 
4258 rajveer 3641 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3642 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3643 
    args = markTransactionAsPaymentFlagRemoved_args()
3644 
    args.transactionId = transactionId
4247 rajveer 3645 
    args.write(self._oprot)
3646 
    self._oprot.writeMessageEnd()
3647 
    self._oprot.trans.flush()
3648 
 
4258 rajveer 3649 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3651 
    if mtype == TMessageType.EXCEPTION:
3652 
      x = TApplicationException()
3653 
      x.read(self._iprot)
3654 
      self._iprot.readMessageEnd()
3655 
      raise x
4258 rajveer 3656 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3657 
    result.read(self._iprot)
3658 
    self._iprot.readMessageEnd()
3659 
    if result.ex is not None:
3660 
      raise result.ex
3661 
    return
3662 
 
4259 anupam.sin 3663 
  def refundTransaction(self, transactionId, refundedBy, reason):
3664 
    """
3665 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3666 
    need to be cancelled
4247 rajveer 3667 
 
4259 anupam.sin 3668 
    Parameters:
3669 
     - transactionId
3670 
     - refundedBy
3671 
     - reason
3672 
    """
3673 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3674 
    self.recv_refundTransaction()
3675 
 
3676 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3677 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3678 
    args = refundTransaction_args()
3679 
    args.transactionId = transactionId
3680 
    args.refundedBy = refundedBy
3681 
    args.reason = reason
3682 
    args.write(self._oprot)
3683 
    self._oprot.writeMessageEnd()
3684 
    self._oprot.trans.flush()
3685 
 
3686 
  def recv_refundTransaction(self, ):
3687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3688 
    if mtype == TMessageType.EXCEPTION:
3689 
      x = TApplicationException()
3690 
      x.read(self._iprot)
3691 
      self._iprot.readMessageEnd()
3692 
      raise x
3693 
    result = refundTransaction_result()
3694 
    result.read(self._iprot)
3695 
    self._iprot.readMessageEnd()
3696 
    if result.ex is not None:
3697 
      raise result.ex
3698 
    return
3699 
 
4324 mandeep.dh 3700 
  def updateShipmentAddress(self, orderId, addressId):
3701 
    """
3702 
    Updates shipment address of an order. Delivery and shipping date estimates
3703 
    etc. are also updated here.
3704 
 
3705 
    Throws TransactionServiceException in case address change is not
3706 
    possible due to certain reasons such as new pincode in address is
3707 
    not serviceable etc.
3708 
 
3709 
    Parameters:
3710 
     - orderId
3711 
     - addressId
3712 
    """
3713 
    self.send_updateShipmentAddress(orderId, addressId)
3714 
    self.recv_updateShipmentAddress()
3715 
 
3716 
  def send_updateShipmentAddress(self, orderId, addressId):
3717 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3718 
    args = updateShipmentAddress_args()
3719 
    args.orderId = orderId
3720 
    args.addressId = addressId
3721 
    args.write(self._oprot)
3722 
    self._oprot.writeMessageEnd()
3723 
    self._oprot.trans.flush()
3724 
 
3725 
  def recv_updateShipmentAddress(self, ):
3726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3727 
    if mtype == TMessageType.EXCEPTION:
3728 
      x = TApplicationException()
3729 
      x.read(self._iprot)
3730 
      self._iprot.readMessageEnd()
3731 
      raise x
3732 
    result = updateShipmentAddress_result()
3733 
    result.read(self._iprot)
3734 
    self._iprot.readMessageEnd()
3735 
    if result.ex is not None:
3736 
      raise result.ex
3737 
    return
3738 
 
4285 rajveer 3739 
  def acceptOrdersForItemId(self, itemId, inventory):
3740 
    """
3741 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3742 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3743 
 
4285 rajveer 3744 
    Parameters:
3745 
     - itemId
3746 
     - inventory
3747 
    """
3748 
    self.send_acceptOrdersForItemId(itemId, inventory)
3749 
    return self.recv_acceptOrdersForItemId()
3750 
 
3751 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3752 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3753 
    args = acceptOrdersForItemId_args()
3754 
    args.itemId = itemId
3755 
    args.inventory = inventory
3756 
    args.write(self._oprot)
3757 
    self._oprot.writeMessageEnd()
3758 
    self._oprot.trans.flush()
3759 
 
3760 
  def recv_acceptOrdersForItemId(self, ):
3761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3762 
    if mtype == TMessageType.EXCEPTION:
3763 
      x = TApplicationException()
3764 
      x.read(self._iprot)
3765 
      self._iprot.readMessageEnd()
3766 
      raise x
3767 
    result = acceptOrdersForItemId_result()
3768 
    result.read(self._iprot)
3769 
    self._iprot.readMessageEnd()
3770 
    if result.success is not None:
3771 
      return result.success
3772 
    if result.ex is not None:
3773 
      raise result.ex
3774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3775 
 
4369 rajveer 3776 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3777 
    """
3778 
    Parameters:
3779 
     - vendorId
3780 
     - itemId
3781 
     - quantity
3782 
     - estimate
4369 rajveer 3783 
     - isReminder
4303 rajveer 3784 
    """
4369 rajveer 3785 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3786 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3787 
 
4369 rajveer 3788 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3789 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3790 
    args = markOrdersAsPORaised_args()
3791 
    args.vendorId = vendorId
3792 
    args.itemId = itemId
3793 
    args.quantity = quantity
3794 
    args.estimate = estimate
4369 rajveer 3795 
    args.isReminder = isReminder
4303 rajveer 3796 
    args.write(self._oprot)
3797 
    self._oprot.writeMessageEnd()
3798 
    self._oprot.trans.flush()
3799 
 
3800 
  def recv_markOrdersAsPORaised(self, ):
3801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3802 
    if mtype == TMessageType.EXCEPTION:
3803 
      x = TApplicationException()
3804 
      x.read(self._iprot)
3805 
      self._iprot.readMessageEnd()
3806 
      raise x
3807 
    result = markOrdersAsPORaised_result()
3808 
    result.read(self._iprot)
3809 
    self._iprot.readMessageEnd()
3810 
    if result.ex is not None:
3811 
      raise result.ex
3812 
    return
3813 
 
4369 rajveer 3814 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3815 
    """
3816 
    Parameters:
3817 
     - vendorId
3818 
     - itemId
3819 
     - quantity
3820 
     - estimate
4369 rajveer 3821 
     - isReminder
4303 rajveer 3822 
    """
4369 rajveer 3823 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3824 
    self.recv_markOrdersAsReversalInitiated()
3825 
 
4369 rajveer 3826 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3827 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3828 
    args = markOrdersAsReversalInitiated_args()
3829 
    args.vendorId = vendorId
3830 
    args.itemId = itemId
3831 
    args.quantity = quantity
3832 
    args.estimate = estimate
4369 rajveer 3833 
    args.isReminder = isReminder
4303 rajveer 3834 
    args.write(self._oprot)
3835 
    self._oprot.writeMessageEnd()
3836 
    self._oprot.trans.flush()
3837 
 
3838 
  def recv_markOrdersAsReversalInitiated(self, ):
3839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3840 
    if mtype == TMessageType.EXCEPTION:
3841 
      x = TApplicationException()
3842 
      x.read(self._iprot)
3843 
      self._iprot.readMessageEnd()
3844 
      raise x
3845 
    result = markOrdersAsReversalInitiated_result()
3846 
    result.read(self._iprot)
3847 
    self._iprot.readMessageEnd()
3848 
    if result.ex is not None:
3849 
      raise result.ex
3850 
    return
3851 
 
4369 rajveer 3852 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3853 
    """
3854 
    Parameters:
3855 
     - vendorId
3856 
     - itemId
3857 
     - quantity
3858 
     - estimate
4369 rajveer 3859 
     - isReminder
4303 rajveer 3860 
    """
4369 rajveer 3861 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3862 
    self.recv_markOrdersAsNotAvailabke()
3863 
 
4369 rajveer 3864 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3865 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3866 
    args = markOrdersAsNotAvailabke_args()
3867 
    args.vendorId = vendorId
3868 
    args.itemId = itemId
3869 
    args.quantity = quantity
3870 
    args.estimate = estimate
4369 rajveer 3871 
    args.isReminder = isReminder
4303 rajveer 3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_markOrdersAsNotAvailabke(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = markOrdersAsNotAvailabke_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3886 
    if result.ex is not None:
3887 
      raise result.ex
3888 
    return
3889 
 
4369 rajveer 3890 
  def markOrdersAsTimeout(self, vendorId):
3891 
    """
3892 
    Parameters:
3893 
     - vendorId
3894 
    """
3895 
    self.send_markOrdersAsTimeout(vendorId)
3896 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3897 
 
4369 rajveer 3898 
  def send_markOrdersAsTimeout(self, vendorId):
3899 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3900 
    args = markOrdersAsTimeout_args()
3901 
    args.vendorId = vendorId
3902 
    args.write(self._oprot)
3903 
    self._oprot.writeMessageEnd()
3904 
    self._oprot.trans.flush()
3905 
 
3906 
  def recv_markOrdersAsTimeout(self, ):
3907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3908 
    if mtype == TMessageType.EXCEPTION:
3909 
      x = TApplicationException()
3910 
      x.read(self._iprot)
3911 
      self._iprot.readMessageEnd()
3912 
      raise x
3913 
    result = markOrdersAsTimeout_result()
3914 
    result.read(self._iprot)
3915 
    self._iprot.readMessageEnd()
3916 
    if result.success is not None:
3917 
      return result.success
3918 
    if result.ex is not None:
3919 
      raise result.ex
3920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3921 
 
4662 rajveer 3922 
  def markOrderAsLostInTransit(self, orderId):
3923 
    """
3924 
    Mark order as LOST_IN_TRANSIT
3925 
 
3926 
    Parameters:
3927 
     - orderId
3928 
    """
3929 
    self.send_markOrderAsLostInTransit(orderId)
3930 
    return self.recv_markOrderAsLostInTransit()
3931 
 
3932 
  def send_markOrderAsLostInTransit(self, orderId):
3933 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3934 
    args = markOrderAsLostInTransit_args()
3935 
    args.orderId = orderId
3936 
    args.write(self._oprot)
3937 
    self._oprot.writeMessageEnd()
3938 
    self._oprot.trans.flush()
3939 
 
3940 
  def recv_markOrderAsLostInTransit(self, ):
3941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3942 
    if mtype == TMessageType.EXCEPTION:
3943 
      x = TApplicationException()
3944 
      x.read(self._iprot)
3945 
      self._iprot.readMessageEnd()
3946 
      raise x
3947 
    result = markOrderAsLostInTransit_result()
3948 
    result.read(self._iprot)
3949 
    self._iprot.readMessageEnd()
3950 
    if result.success is not None:
3951 
      return result.success
3952 
    if result.ex is not None:
3953 
      raise result.ex
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3955 
 
4386 anupam.sin 3956 
  def getOrderForAwb(self, awb):
3957 
    """
3958 
    Returns the order corresponding to an AWB number
4369 rajveer 3959 
 
4386 anupam.sin 3960 
    Parameters:
3961 
     - awb
3962 
    """
3963 
    self.send_getOrderForAwb(awb)
3964 
    return self.recv_getOrderForAwb()
3965 
 
3966 
  def send_getOrderForAwb(self, awb):
3967 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3968 
    args = getOrderForAwb_args()
3969 
    args.awb = awb
3970 
    args.write(self._oprot)
3971 
    self._oprot.writeMessageEnd()
3972 
    self._oprot.trans.flush()
3973 
 
3974 
  def recv_getOrderForAwb(self, ):
3975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3976 
    if mtype == TMessageType.EXCEPTION:
3977 
      x = TApplicationException()
3978 
      x.read(self._iprot)
3979 
      self._iprot.readMessageEnd()
3980 
      raise x
3981 
    result = getOrderForAwb_result()
3982 
    result.read(self._iprot)
3983 
    self._iprot.readMessageEnd()
3984 
    if result.success is not None:
3985 
      return result.success
3986 
    if result.ex is not None:
3987 
      raise result.ex
3988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3989 
 
4506 phani.kuma 3990 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3991 
    """
3992 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3993 
 
4506 phani.kuma 3994 
    Parameters:
3995 
     - logistics_provider_id
3996 
     - order_status
3997 
    """
3998 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3999 
    return self.recv_getOrdersForProviderForStatus()
4000 
 
4001 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4002 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4003 
    args = getOrdersForProviderForStatus_args()
4004 
    args.logistics_provider_id = logistics_provider_id
4005 
    args.order_status = order_status
4006 
    args.write(self._oprot)
4007 
    self._oprot.writeMessageEnd()
4008 
    self._oprot.trans.flush()
4009 
 
4010 
  def recv_getOrdersForProviderForStatus(self, ):
4011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4012 
    if mtype == TMessageType.EXCEPTION:
4013 
      x = TApplicationException()
4014 
      x.read(self._iprot)
4015 
      self._iprot.readMessageEnd()
4016 
      raise x
4017 
    result = getOrdersForProviderForStatus_result()
4018 
    result.read(self._iprot)
4019 
    self._iprot.readMessageEnd()
4020 
    if result.success is not None:
4021 
      return result.success
4022 
    if result.ex is not None:
4023 
      raise result.ex
4024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4025 
 
4600 varun.gupt 4026 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4027 
    """
4028 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4029 
 
4600 varun.gupt 4030 
    Parameters:
4031 
     - vendorId
4032 
     - billingDateFrom
4033 
     - billingDateTo
4034 
    """
4035 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4036 
    return self.recv_getBilledOrdersForVendor()
4037 
 
4038 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4039 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4040 
    args = getBilledOrdersForVendor_args()
4041 
    args.vendorId = vendorId
4042 
    args.billingDateFrom = billingDateFrom
4043 
    args.billingDateTo = billingDateTo
4044 
    args.write(self._oprot)
4045 
    self._oprot.writeMessageEnd()
4046 
    self._oprot.trans.flush()
4047 
 
4048 
  def recv_getBilledOrdersForVendor(self, ):
4049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4050 
    if mtype == TMessageType.EXCEPTION:
4051 
      x = TApplicationException()
4052 
      x.read(self._iprot)
4053 
      self._iprot.readMessageEnd()
4054 
      raise x
4055 
    result = getBilledOrdersForVendor_result()
4056 
    result.read(self._iprot)
4057 
    self._iprot.readMessageEnd()
4058 
    if result.success is not None:
4059 
      return result.success
4060 
    if result.ex is not None:
4061 
      raise result.ex
4062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4063 
 
4607 rajveer 4064 
  def getSlippedSippingDateOrders(self, ):
4065 
    self.send_getSlippedSippingDateOrders()
4066 
    return self.recv_getSlippedSippingDateOrders()
4067 
 
4068 
  def send_getSlippedSippingDateOrders(self, ):
4069 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4070 
    args = getSlippedSippingDateOrders_args()
4071 
    args.write(self._oprot)
4072 
    self._oprot.writeMessageEnd()
4073 
    self._oprot.trans.flush()
4074 
 
4075 
  def recv_getSlippedSippingDateOrders(self, ):
4076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4077 
    if mtype == TMessageType.EXCEPTION:
4078 
      x = TApplicationException()
4079 
      x.read(self._iprot)
4080 
      self._iprot.readMessageEnd()
4081 
      raise x
4082 
    result = getSlippedSippingDateOrders_result()
4083 
    result.read(self._iprot)
4084 
    self._iprot.readMessageEnd()
4085 
    if result.success is not None:
4086 
      return result.success
4087 
    if result.ex is not None:
4088 
      raise result.ex
4089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4090 
 
4709 rajveer 4091 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4092 
    """
4093 
    Parameters:
4094 
     - cancelDateFrom
4095 
     - cancelDateTo
4096 
    """
4097 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4098 
    return self.recv_getCancelledOrders()
4099 
 
4100 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4101 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4102 
    args = getCancelledOrders_args()
4103 
    args.cancelDateFrom = cancelDateFrom
4104 
    args.cancelDateTo = cancelDateTo
4105 
    args.write(self._oprot)
4106 
    self._oprot.writeMessageEnd()
4107 
    self._oprot.trans.flush()
4108 
 
4109 
  def recv_getCancelledOrders(self, ):
4110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4111 
    if mtype == TMessageType.EXCEPTION:
4112 
      x = TApplicationException()
4113 
      x.read(self._iprot)
4114 
      self._iprot.readMessageEnd()
4115 
      raise x
4116 
    result = getCancelledOrders_result()
4117 
    result.read(self._iprot)
4118 
    self._iprot.readMessageEnd()
4119 
    if result.success is not None:
4120 
      return result.success
4121 
    if result.ex is not None:
4122 
      raise result.ex
4123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4124 
 
4600 varun.gupt 4125 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4126 
    """
4127 
    Parameters:
4128 
     - mapAWBAndAmount
4129 
    """
4130 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4131 
    self.recv_saveBluedartSettlements()
4132 
 
4133 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4134 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4135 
    args = saveBluedartSettlements_args()
4136 
    args.mapAWBAndAmount = mapAWBAndAmount
4137 
    args.write(self._oprot)
4138 
    self._oprot.writeMessageEnd()
4139 
    self._oprot.trans.flush()
4140 
 
4141 
  def recv_saveBluedartSettlements(self, ):
4142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4143 
    if mtype == TMessageType.EXCEPTION:
4144 
      x = TApplicationException()
4145 
      x.read(self._iprot)
4146 
      self._iprot.readMessageEnd()
4147 
      raise x
4148 
    result = saveBluedartSettlements_result()
4149 
    result.read(self._iprot)
4150 
    self._iprot.readMessageEnd()
4151 
    if result.ex is not None:
4152 
      raise result.ex
4153 
    return
4154 
 
4155 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4156 
    """
4157 
    Parameters:
4158 
     - settlementDate
4159 
     - paymentGatewayId
4160 
     - paymentId
4161 
     - serviceTax
4162 
     - otherCharges
4163 
     - netCollection
4164 
    """
4165 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4166 
    self.recv_savePaymentSettlements()
4167 
 
4168 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4169 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4170 
    args = savePaymentSettlements_args()
4171 
    args.settlementDate = settlementDate
4172 
    args.paymentGatewayId = paymentGatewayId
4173 
    args.paymentId = paymentId
4174 
    args.serviceTax = serviceTax
4175 
    args.otherCharges = otherCharges
4176 
    args.netCollection = netCollection
4177 
    args.write(self._oprot)
4178 
    self._oprot.writeMessageEnd()
4179 
    self._oprot.trans.flush()
4180 
 
4181 
  def recv_savePaymentSettlements(self, ):
4182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4183 
    if mtype == TMessageType.EXCEPTION:
4184 
      x = TApplicationException()
4185 
      x.read(self._iprot)
4186 
      self._iprot.readMessageEnd()
4187 
      raise x
4188 
    result = savePaymentSettlements_result()
4189 
    result.read(self._iprot)
4190 
    self._iprot.readMessageEnd()
4191 
    if result.ex is not None:
4192 
      raise result.ex
4193 
    return
4194 
 
4195 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4196 
    """
4197 
    Parameters:
4198 
     - settlementId
4199 
     - settlementDate
4200 
     - transactionDateFrom
4201 
     - transactionDateTo
4202 
     - amount
4203 
    """
4204 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4205 
    self.recv_saveEBSSettlementSummary()
4206 
 
4207 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4208 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4209 
    args = saveEBSSettlementSummary_args()
4210 
    args.settlementId = settlementId
4211 
    args.settlementDate = settlementDate
4212 
    args.transactionDateFrom = transactionDateFrom
4213 
    args.transactionDateTo = transactionDateTo
4214 
    args.amount = amount
4215 
    args.write(self._oprot)
4216 
    self._oprot.writeMessageEnd()
4217 
    self._oprot.trans.flush()
4218 
 
4219 
  def recv_saveEBSSettlementSummary(self, ):
4220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4221 
    if mtype == TMessageType.EXCEPTION:
4222 
      x = TApplicationException()
4223 
      x.read(self._iprot)
4224 
      self._iprot.readMessageEnd()
4225 
      raise x
4226 
    result = saveEBSSettlementSummary_result()
4227 
    result.read(self._iprot)
4228 
    self._iprot.readMessageEnd()
4229 
    if result.ex is not None:
4230 
      raise result.ex
4231 
    return
4232 
 
4233 
  def getSettlementForPaymentId(self, paymentId):
4234 
    """
4235 
    Parameters:
4236 
     - paymentId
4237 
    """
4238 
    self.send_getSettlementForPaymentId(paymentId)
4239 
    return self.recv_getSettlementForPaymentId()
4240 
 
4241 
  def send_getSettlementForPaymentId(self, paymentId):
4242 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4243 
    args = getSettlementForPaymentId_args()
4244 
    args.paymentId = paymentId
4245 
    args.write(self._oprot)
4246 
    self._oprot.writeMessageEnd()
4247 
    self._oprot.trans.flush()
4248 
 
4249 
  def recv_getSettlementForPaymentId(self, ):
4250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4251 
    if mtype == TMessageType.EXCEPTION:
4252 
      x = TApplicationException()
4253 
      x.read(self._iprot)
4254 
      self._iprot.readMessageEnd()
4255 
      raise x
4256 
    result = getSettlementForPaymentId_result()
4257 
    result.read(self._iprot)
4258 
    self._iprot.readMessageEnd()
4259 
    if result.success is not None:
4260 
      return result.success
4261 
    if result.ex is not None:
4262 
      raise result.ex
4263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4264 
 
4265 
  def getEBSSettlementSummaries(self, ):
4266 
    self.send_getEBSSettlementSummaries()
4267 
    return self.recv_getEBSSettlementSummaries()
4268 
 
4269 
  def send_getEBSSettlementSummaries(self, ):
4270 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4271 
    args = getEBSSettlementSummaries_args()
4272 
    args.write(self._oprot)
4273 
    self._oprot.writeMessageEnd()
4274 
    self._oprot.trans.flush()
4275 
 
4276 
  def recv_getEBSSettlementSummaries(self, ):
4277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4278 
    if mtype == TMessageType.EXCEPTION:
4279 
      x = TApplicationException()
4280 
      x.read(self._iprot)
4281 
      self._iprot.readMessageEnd()
4282 
      raise x
4283 
    result = getEBSSettlementSummaries_result()
4284 
    result.read(self._iprot)
4285 
    self._iprot.readMessageEnd()
4286 
    if result.success is not None:
4287 
      return result.success
4288 
    if result.ex is not None:
4289 
      raise result.ex
4290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4291 
 
4292 
  def markEBSSettlementUploaded(self, settlementId):
4293 
    """
4294 
    Parameters:
4295 
     - settlementId
4296 
    """
4297 
    self.send_markEBSSettlementUploaded(settlementId)
4298 
    self.recv_markEBSSettlementUploaded()
4299 
 
4300 
  def send_markEBSSettlementUploaded(self, settlementId):
4301 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4302 
    args = markEBSSettlementUploaded_args()
4303 
    args.settlementId = settlementId
4304 
    args.write(self._oprot)
4305 
    self._oprot.writeMessageEnd()
4306 
    self._oprot.trans.flush()
4307 
 
4308 
  def recv_markEBSSettlementUploaded(self, ):
4309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4310 
    if mtype == TMessageType.EXCEPTION:
4311 
      x = TApplicationException()
4312 
      x.read(self._iprot)
4313 
      self._iprot.readMessageEnd()
4314 
      raise x
4315 
    result = markEBSSettlementUploaded_result()
4316 
    result.read(self._iprot)
4317 
    self._iprot.readMessageEnd()
4318 
    if result.ex is not None:
4319 
      raise result.ex
4320 
    return
4321 
 
4322 
  def getEBSSettlementDate(self, settlementId):
4323 
    """
4324 
    Parameters:
4325 
     - settlementId
4326 
    """
4327 
    self.send_getEBSSettlementDate(settlementId)
4328 
    return self.recv_getEBSSettlementDate()
4329 
 
4330 
  def send_getEBSSettlementDate(self, settlementId):
4331 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4332 
    args = getEBSSettlementDate_args()
4333 
    args.settlementId = settlementId
4334 
    args.write(self._oprot)
4335 
    self._oprot.writeMessageEnd()
4336 
    self._oprot.trans.flush()
4337 
 
4338 
  def recv_getEBSSettlementDate(self, ):
4339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4340 
    if mtype == TMessageType.EXCEPTION:
4341 
      x = TApplicationException()
4342 
      x.read(self._iprot)
4343 
      self._iprot.readMessageEnd()
4344 
      raise x
4345 
    result = getEBSSettlementDate_result()
4346 
    result.read(self._iprot)
4347 
    self._iprot.readMessageEnd()
4348 
    if result.success is not None:
4349 
      return result.success
4350 
    if result.ex is not None:
4351 
      raise result.ex
4352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4353 
 
4715 varun.gupt 4354 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4355 
    """
4356 
    Parameters:
4357 
     - settlementDateFrom
4358 
     - settlementDateTo
4359 
     - isRefund
4360 
    """
4361 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4362 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4363 
 
4715 varun.gupt 4364 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4365 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4366 
    args = getSettlementsByDate_args()
4367 
    args.settlementDateFrom = settlementDateFrom
4368 
    args.settlementDateTo = settlementDateTo
4369 
    args.isRefund = isRefund
4370 
    args.write(self._oprot)
4371 
    self._oprot.writeMessageEnd()
4372 
    self._oprot.trans.flush()
4373 
 
4374 
  def recv_getSettlementsByDate(self, ):
4375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4376 
    if mtype == TMessageType.EXCEPTION:
4377 
      x = TApplicationException()
4378 
      x.read(self._iprot)
4379 
      self._iprot.readMessageEnd()
4380 
      raise x
4381 
    result = getSettlementsByDate_result()
4382 
    result.read(self._iprot)
4383 
    self._iprot.readMessageEnd()
4384 
    if result.success is not None:
4385 
      return result.success
4386 
    if result.ex is not None:
4387 
      raise result.ex
4388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4389 
 
4390 
  def getReshippedOrderIds(self, orderIds):
4391 
    """
4392 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4393 
 
4394 
    Parameters:
4395 
     - orderIds
4396 
    """
4397 
    self.send_getReshippedOrderIds(orderIds)
4398 
    return self.recv_getReshippedOrderIds()
4399 
 
4400 
  def send_getReshippedOrderIds(self, orderIds):
4401 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4402 
    args = getReshippedOrderIds_args()
4403 
    args.orderIds = orderIds
4404 
    args.write(self._oprot)
4405 
    self._oprot.writeMessageEnd()
4406 
    self._oprot.trans.flush()
4407 
 
4408 
  def recv_getReshippedOrderIds(self, ):
4409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4410 
    if mtype == TMessageType.EXCEPTION:
4411 
      x = TApplicationException()
4412 
      x.read(self._iprot)
4413 
      self._iprot.readMessageEnd()
4414 
      raise x
4415 
    result = getReshippedOrderIds_result()
4416 
    result.read(self._iprot)
4417 
    self._iprot.readMessageEnd()
4418 
    if result.success is not None:
4419 
      return result.success
4420 
    if result.ex is not None:
4421 
      raise result.ex
4422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4423 
 
4757 mandeep.dh 4424 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4425 
    """
4426 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4427 
    the quantities for which the PO is raised.
4715 varun.gupt 4428 
 
4757 mandeep.dh 4429 
    Parameters:
4430 
     - itemIdQuantityMap
4431 
     - purchaseOrderId
4432 
     - warehouseId
4433 
    """
4434 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4435 
    self.recv_updateOrdersAsPORaised()
4436 
 
4437 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4438 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4439 
    args = updateOrdersAsPORaised_args()
4440 
    args.itemIdQuantityMap = itemIdQuantityMap
4441 
    args.purchaseOrderId = purchaseOrderId
4442 
    args.warehouseId = warehouseId
4443 
    args.write(self._oprot)
4444 
    self._oprot.writeMessageEnd()
4445 
    self._oprot.trans.flush()
4446 
 
4447 
  def recv_updateOrdersAsPORaised(self, ):
4448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4449 
    if mtype == TMessageType.EXCEPTION:
4450 
      x = TApplicationException()
4451 
      x.read(self._iprot)
4452 
      self._iprot.readMessageEnd()
4453 
      raise x
4454 
    result = updateOrdersAsPORaised_result()
4455 
    result.read(self._iprot)
4456 
    self._iprot.readMessageEnd()
4457 
    if result.ex is not None:
4458 
      raise result.ex
4459 
    return
4460 
 
4461 
 
3376 rajveer 4462 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4463 
  def __init__(self, handler):
3376 rajveer 4464 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4465 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4466 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4467 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4468 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4469 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4470 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4471 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4472 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4473 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4474 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4475 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4476 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4477 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4478 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4479 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4480 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4481 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4482 
    self._processMap["createOrder"] = Processor.process_createOrder
4483 
    self._processMap["getOrder"] = Processor.process_getOrder
4484 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4485 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4486 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4487 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4488 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4489 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4490 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4491 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4492 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4493 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4494 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4495 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4496 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4497 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4498 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4499 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4500 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4501 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4502 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4503 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4504 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4505 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4506 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4507 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4508 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4509 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4510 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4511 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4512 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4513 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4514 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4515 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4516 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4517 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4518 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4519 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4520 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4521 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4522 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4523 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4524 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4525 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4526 
    self._processMap["changeItem"] = Processor.process_changeItem
4527 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4528 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4529 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4530 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4531 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4532 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4533 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4534 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4535 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4536 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4537 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4538 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4539 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4540 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4541 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4542 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4543 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4544 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4545 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4546 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4547 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4548 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4549 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4550 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4551 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4552 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4553 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4554 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4555 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4556 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4557 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4558 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4559 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4560 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
94 ashish 4561 
 
4562 
  def process(self, iprot, oprot):
4563 
    (name, type, seqid) = iprot.readMessageBegin()
4564 
    if name not in self._processMap:
4565 
      iprot.skip(TType.STRUCT)
4566 
      iprot.readMessageEnd()
4567 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4568 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4569 
      x.write(oprot)
4570 
      oprot.writeMessageEnd()
4571 
      oprot.trans.flush()
4572 
      return
4573 
    else:
4574 
      self._processMap[name](self, seqid, iprot, oprot)
4575 
    return True
4576 
 
4577 
  def process_createTransaction(self, seqid, iprot, oprot):
4578 
    args = createTransaction_args()
4579 
    args.read(iprot)
4580 
    iprot.readMessageEnd()
4581 
    result = createTransaction_result()
4582 
    try:
132 ashish 4583 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4584 
    except TransactionServiceException, ex:
4585 
      result.ex = ex
4586 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4587 
    result.write(oprot)
4588 
    oprot.writeMessageEnd()
4589 
    oprot.trans.flush()
4590 
 
4591 
  def process_getTransaction(self, seqid, iprot, oprot):
4592 
    args = getTransaction_args()
4593 
    args.read(iprot)
4594 
    iprot.readMessageEnd()
4595 
    result = getTransaction_result()
4596 
    try:
4597 
      result.success = self._handler.getTransaction(args.id)
4598 
    except TransactionServiceException, ex:
4599 
      result.ex = ex
4600 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4601 
    result.write(oprot)
4602 
    oprot.writeMessageEnd()
4603 
    oprot.trans.flush()
4604 
 
4605 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4606 
    args = getTransactionsForCustomer_args()
4607 
    args.read(iprot)
4608 
    iprot.readMessageEnd()
4609 
    result = getTransactionsForCustomer_result()
4610 
    try:
4611 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4612 
    except TransactionServiceException, ex:
4613 
      result.ex = ex
4614 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4615 
    result.write(oprot)
4616 
    oprot.writeMessageEnd()
4617 
    oprot.trans.flush()
4618 
 
132 ashish 4619 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4620 
    args = getTransactionsForShoppingCartId_args()
4621 
    args.read(iprot)
4622 
    iprot.readMessageEnd()
4623 
    result = getTransactionsForShoppingCartId_result()
4624 
    try:
4625 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4626 
    except TransactionServiceException, ex:
4627 
      result.ex = ex
4628 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
94 ashish 4633 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4634 
    args = getTransactionStatus_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = getTransactionStatus_result()
4638 
    try:
4639 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4640 
    except TransactionServiceException, ex:
4641 
      result.ex = ex
4642 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4643 
    result.write(oprot)
4644 
    oprot.writeMessageEnd()
4645 
    oprot.trans.flush()
4646 
 
4647 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4648 
    args = changeTransactionStatus_args()
4649 
    args.read(iprot)
4650 
    iprot.readMessageEnd()
4651 
    result = changeTransactionStatus_result()
4652 
    try:
4653 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4654 
    except TransactionServiceException, ex:
4655 
      result.ex = ex
4656 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4657 
    result.write(oprot)
4658 
    oprot.writeMessageEnd()
4659 
    oprot.trans.flush()
4660 
 
1398 varun.gupt 4661 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4662 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4663 
    args.read(iprot)
4664 
    iprot.readMessageEnd()
1398 varun.gupt 4665 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4666 
    try:
1398 varun.gupt 4667 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4668 
    except TransactionServiceException, ex:
4669 
      result.ex = ex
1398 varun.gupt 4670 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4671 
    result.write(oprot)
4672 
    oprot.writeMessageEnd()
4673 
    oprot.trans.flush()
4674 
 
483 rajveer 4675 
  def process_getAllOrders(self, seqid, iprot, oprot):
4676 
    args = getAllOrders_args()
94 ashish 4677 
    args.read(iprot)
4678 
    iprot.readMessageEnd()
483 rajveer 4679 
    result = getAllOrders_result()
94 ashish 4680 
    try:
483 rajveer 4681 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4682 
    except TransactionServiceException, ex:
4683 
      result.ex = ex
483 rajveer 4684 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4685 
    result.write(oprot)
4686 
    oprot.writeMessageEnd()
4687 
    oprot.trans.flush()
4688 
 
4133 chandransh 4689 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4690 
    args = getOrdersInBatch_args()
4691 
    args.read(iprot)
4692 
    iprot.readMessageEnd()
4693 
    result = getOrdersInBatch_result()
4694 
    try:
4695 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4696 
    except TransactionServiceException, ex:
4697 
      result.ex = ex
4698 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4699 
    result.write(oprot)
4700 
    oprot.writeMessageEnd()
4701 
    oprot.trans.flush()
4702 
 
4703 
  def process_getOrderCount(self, seqid, iprot, oprot):
4704 
    args = getOrderCount_args()
4705 
    args.read(iprot)
4706 
    iprot.readMessageEnd()
4707 
    result = getOrderCount_result()
4708 
    try:
4709 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4710 
    except TransactionServiceException, ex:
4711 
      result.ex = ex
4712 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4713 
    result.write(oprot)
4714 
    oprot.writeMessageEnd()
4715 
    oprot.trans.flush()
4716 
 
999 varun.gupt 4717 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4718 
    args = getOrdersByBillingDate_args()
4719 
    args.read(iprot)
4720 
    iprot.readMessageEnd()
4721 
    result = getOrdersByBillingDate_result()
4722 
    try:
4723 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4724 
    except TransactionServiceException, ex:
4725 
      result.ex = ex
4726 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
3427 chandransh 4731 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4732 
    args = getOrdersByShippingDate_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getOrdersByShippingDate_result()
4736 
    try:
3451 chandransh 4737 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4738 
    except TransactionServiceException, ex:
4739 
      result.ex = ex
4740 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4741 
    result.write(oprot)
4742 
    oprot.writeMessageEnd()
4743 
    oprot.trans.flush()
4744 
 
1382 varun.gupt 4745 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4746 
    args = getReturnableOrdersForCustomer_args()
4747 
    args.read(iprot)
4748 
    iprot.readMessageEnd()
4749 
    result = getReturnableOrdersForCustomer_result()
4750 
    try:
4751 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4752 
    except TransactionServiceException, ex:
4753 
      result.ex = ex
4754 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4759 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4760 
    args = getCancellableOrdersForCustomer_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = getCancellableOrdersForCustomer_result()
4764 
    try:
4765 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4766 
    except TransactionServiceException, ex:
4767 
      result.ex = ex
4768 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4769 
    result.write(oprot)
4770 
    oprot.writeMessageEnd()
4771 
    oprot.trans.flush()
4772 
 
483 rajveer 4773 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4774 
    args = changeOrderStatus_args()
94 ashish 4775 
    args.read(iprot)
4776 
    iprot.readMessageEnd()
483 rajveer 4777 
    result = changeOrderStatus_result()
94 ashish 4778 
    try:
483 rajveer 4779 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4780 
    except TransactionServiceException, ex:
4781 
      result.ex = ex
483 rajveer 4782 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4783 
    result.write(oprot)
4784 
    oprot.writeMessageEnd()
4785 
    oprot.trans.flush()
4786 
 
483 rajveer 4787 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4788 
    args = getOrdersForTransaction_args()
94 ashish 4789 
    args.read(iprot)
4790 
    iprot.readMessageEnd()
483 rajveer 4791 
    result = getOrdersForTransaction_result()
94 ashish 4792 
    try:
1528 ankur.sing 4793 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4794 
    except TransactionServiceException, ex:
4795 
      result.ex = ex
483 rajveer 4796 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4797 
    result.write(oprot)
4798 
    oprot.writeMessageEnd()
4799 
    oprot.trans.flush()
4800 
 
483 rajveer 4801 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4802 
    args = getOrdersForCustomer_args()
94 ashish 4803 
    args.read(iprot)
4804 
    iprot.readMessageEnd()
483 rajveer 4805 
    result = getOrdersForCustomer_result()
94 ashish 4806 
    try:
3014 chandransh 4807 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4808 
    except TransactionServiceException, ex:
4809 
      result.ex = ex
483 rajveer 4810 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4811 
    result.write(oprot)
4812 
    oprot.writeMessageEnd()
4813 
    oprot.trans.flush()
4814 
 
483 rajveer 4815 
  def process_createOrder(self, seqid, iprot, oprot):
4816 
    args = createOrder_args()
94 ashish 4817 
    args.read(iprot)
4818 
    iprot.readMessageEnd()
483 rajveer 4819 
    result = createOrder_result()
94 ashish 4820 
    try:
483 rajveer 4821 
      result.success = self._handler.createOrder(args.order)
94 ashish 4822 
    except TransactionServiceException, ex:
4823 
      result.ex = ex
483 rajveer 4824 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4825 
    result.write(oprot)
4826 
    oprot.writeMessageEnd()
4827 
    oprot.trans.flush()
4828 
 
483 rajveer 4829 
  def process_getOrder(self, seqid, iprot, oprot):
4830 
    args = getOrder_args()
94 ashish 4831 
    args.read(iprot)
4832 
    iprot.readMessageEnd()
483 rajveer 4833 
    result = getOrder_result()
94 ashish 4834 
    try:
483 rajveer 4835 
      result.success = self._handler.getOrder(args.id)
94 ashish 4836 
    except TransactionServiceException, ex:
4837 
      result.ex = ex
483 rajveer 4838 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4839 
    result.write(oprot)
4840 
    oprot.writeMessageEnd()
4841 
    oprot.trans.flush()
4842 
 
483 rajveer 4843 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4844 
    args = getLineItemsForOrder_args()
94 ashish 4845 
    args.read(iprot)
4846 
    iprot.readMessageEnd()
483 rajveer 4847 
    result = getLineItemsForOrder_result()
94 ashish 4848 
    try:
483 rajveer 4849 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4850 
    except TransactionServiceException, ex:
4851 
      result.ex = ex
483 rajveer 4852 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4853 
    result.write(oprot)
4854 
    oprot.writeMessageEnd()
4855 
    oprot.trans.flush()
4856 
 
1528 ankur.sing 4857 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4858 
    args = getOrderForCustomer_args()
4859 
    args.read(iprot)
4860 
    iprot.readMessageEnd()
4861 
    result = getOrderForCustomer_result()
4862 
    try:
4863 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4864 
    except TransactionServiceException, ex:
4865 
      result.ex = ex
4866 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4867 
    result.write(oprot)
4868 
    oprot.writeMessageEnd()
4869 
    oprot.trans.flush()
4870 
 
3064 chandransh 4871 
  def process_getAlerts(self, seqid, iprot, oprot):
4872 
    args = getAlerts_args()
4873 
    args.read(iprot)
4874 
    iprot.readMessageEnd()
4875 
    result = getAlerts_result()
4444 rajveer 4876 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4877 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4878 
    result.write(oprot)
4879 
    oprot.writeMessageEnd()
4880 
    oprot.trans.flush()
4881 
 
4394 rajveer 4882 
  def process_addAlert(self, seqid, iprot, oprot):
4883 
    args = addAlert_args()
3064 chandransh 4884 
    args.read(iprot)
4885 
    iprot.readMessageEnd()
4394 rajveer 4886 
    result = addAlert_result()
4444 rajveer 4887 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4888 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4889 
    result.write(oprot)
4890 
    oprot.writeMessageEnd()
4891 
    oprot.trans.flush()
4892 
 
4444 rajveer 4893 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4894 
    args = markAlertsAsSeen_args()
4895 
    args.read(iprot)
4896 
    iprot.readMessageEnd()
4897 
    result = markAlertsAsSeen_result()
4898 
    self._handler.markAlertsAsSeen(args.warehouseId)
4899 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4900 
    result.write(oprot)
4901 
    oprot.writeMessageEnd()
4902 
    oprot.trans.flush()
4903 
 
3064 chandransh 4904 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4905 
    args = getValidOrderCount_args()
4906 
    args.read(iprot)
4907 
    iprot.readMessageEnd()
4908 
    result = getValidOrderCount_result()
4909 
    result.success = self._handler.getValidOrderCount()
4910 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4911 
    result.write(oprot)
4912 
    oprot.writeMessageEnd()
4913 
    oprot.trans.flush()
4914 
 
4915 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4916 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4917 
    args.read(iprot)
4918 
    iprot.readMessageEnd()
4919 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4920 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4921 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4922 
    result.write(oprot)
4923 
    oprot.writeMessageEnd()
4924 
    oprot.trans.flush()
4925 
 
4926 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4927 
    args = getValidOrdersAmountRange_args()
4928 
    args.read(iprot)
4929 
    iprot.readMessageEnd()
4930 
    result = getValidOrdersAmountRange_result()
4931 
    result.success = self._handler.getValidOrdersAmountRange()
4932 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4933 
    result.write(oprot)
4934 
    oprot.writeMessageEnd()
4935 
    oprot.trans.flush()
4936 
 
4937 
  def process_getValidOrders(self, seqid, iprot, oprot):
4938 
    args = getValidOrders_args()
4939 
    args.read(iprot)
4940 
    iprot.readMessageEnd()
4941 
    result = getValidOrders_result()
4942 
    result.success = self._handler.getValidOrders(args.limit)
4943 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4944 
    result.write(oprot)
4945 
    oprot.writeMessageEnd()
4946 
    oprot.trans.flush()
4947 
 
1220 chandransh 4948 
  def process_batchOrders(self, seqid, iprot, oprot):
4949 
    args = batchOrders_args()
4950 
    args.read(iprot)
4951 
    iprot.readMessageEnd()
4952 
    result = batchOrders_result()
4953 
    try:
4954 
      result.success = self._handler.batchOrders(args.warehouseId)
4955 
    except TransactionServiceException, ex:
4956 
      result.ex = ex
4957 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4958 
    result.write(oprot)
4959 
    oprot.writeMessageEnd()
4960 
    oprot.trans.flush()
4961 
 
1208 chandransh 4962 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4963 
    args = markOrderAsOutOfStock_args()
4964 
    args.read(iprot)
4965 
    iprot.readMessageEnd()
4966 
    result = markOrderAsOutOfStock_result()
4967 
    try:
4968 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4969 
    except TransactionServiceException, ex:
4970 
      result.ex = ex
4971 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
3064 chandransh 4976 
  def process_verifyOrder(self, seqid, iprot, oprot):
4977 
    args = verifyOrder_args()
759 chandransh 4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
3064 chandransh 4980 
    result = verifyOrder_result()
759 chandransh 4981 
    try:
3064 chandransh 4982 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4983 
    except TransactionServiceException, ex:
4984 
      result.ex = ex
3064 chandransh 4985 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4986 
    result.write(oprot)
4987 
    oprot.writeMessageEnd()
4988 
    oprot.trans.flush()
4989 
 
3064 chandransh 4990 
  def process_acceptOrder(self, seqid, iprot, oprot):
4991 
    args = acceptOrder_args()
1113 chandransh 4992 
    args.read(iprot)
4993 
    iprot.readMessageEnd()
3064 chandransh 4994 
    result = acceptOrder_result()
1113 chandransh 4995 
    try:
3064 chandransh 4996 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4997 
    except TransactionServiceException, ex:
4998 
      result.ex = ex
3064 chandransh 4999 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5000 
    result.write(oprot)
5001 
    oprot.writeMessageEnd()
5002 
    oprot.trans.flush()
5003 
 
3064 chandransh 5004 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5005 
    args = addBillingDetails_args()
1135 chandransh 5006 
    args.read(iprot)
5007 
    iprot.readMessageEnd()
3064 chandransh 5008 
    result = addBillingDetails_result()
1135 chandransh 5009 
    try:
4763 rajveer 5010 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId, args.authorize)
1135 chandransh 5011 
    except TransactionServiceException, ex:
5012 
      result.ex = ex
3064 chandransh 5013 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
5017 
 
4579 rajveer 5018 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5019 
    args = addInvoiceNumber_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = addInvoiceNumber_result()
5023 
    try:
4763 rajveer 5024 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5025 
    except TransactionServiceException, ex:
5026 
      result.ex = ex
5027 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5028 
    result.write(oprot)
5029 
    oprot.writeMessageEnd()
5030 
    oprot.trans.flush()
5031 
 
3064 chandransh 5032 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
5033 
    args = markOrdersAsManifested_args()
1408 ankur.sing 5034 
    args.read(iprot)
5035 
    iprot.readMessageEnd()
3064 chandransh 5036 
    result = markOrdersAsManifested_result()
5037 
    try:
5038 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5039 
    except TransactionServiceException, ex:
5040 
      result.ex = ex
5041 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5042 
    result.write(oprot)
5043 
    oprot.writeMessageEnd()
5044 
    oprot.trans.flush()
5045 
 
4410 rajveer 5046 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5047 
    args = markOrdersAsShippedFromWarehouse_args()
5048 
    args.read(iprot)
5049 
    iprot.readMessageEnd()
5050 
    result = markOrdersAsShippedFromWarehouse_result()
5051 
    try:
5052 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
5053 
    except TransactionServiceException, ex:
5054 
      result.ex = ex
5055 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5056 
    result.write(oprot)
5057 
    oprot.writeMessageEnd()
5058 
    oprot.trans.flush()
5059 
 
3064 chandransh 5060 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5061 
    args = markOrdersAsPickedUp_args()
304 ashish 5062 
    args.read(iprot)
5063 
    iprot.readMessageEnd()
3064 chandransh 5064 
    result = markOrdersAsPickedUp_result()
5065 
    try:
5066 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5067 
    except TransactionServiceException, ex:
5068 
      result.ex = ex
5069 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
94 ashish 5073 
 
3064 chandransh 5074 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5075 
    args = markOrdersAsDelivered_args()
304 ashish 5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
3064 chandransh 5078 
    result = markOrdersAsDelivered_result()
5079 
    try:
5080 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5081 
    except TransactionServiceException, ex:
5082 
      result.ex = ex
5083 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5084 
    result.write(oprot)
5085 
    oprot.writeMessageEnd()
5086 
    oprot.trans.flush()
5087 
 
3064 chandransh 5088 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5089 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5090 
    args.read(iprot)
5091 
    iprot.readMessageEnd()
3064 chandransh 5092 
    result = markOrdersAsFailed_result()
5093 
    try:
5094 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5095 
    except TransactionServiceException, ex:
5096 
      result.ex = ex
5097 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
304 ashish 5101 
 
3064 chandransh 5102 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5103 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
3064 chandransh 5106 
    result = updateNonDeliveryReason_result()
5107 
    try:
4581 phani.kuma 5108 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5109 
    except TransactionServiceException, ex:
5110 
      result.ex = ex
5111 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5112 
    result.write(oprot)
5113 
    oprot.writeMessageEnd()
5114 
    oprot.trans.flush()
1596 ankur.sing 5115 
 
3064 chandransh 5116 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5117 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5118 
    args.read(iprot)
5119 
    iprot.readMessageEnd()
3064 chandransh 5120 
    result = getUndeliveredOrders_result()
5121 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5122 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5123 
    result.write(oprot)
5124 
    oprot.writeMessageEnd()
5125 
    oprot.trans.flush()
5126 
 
4783 phani.kuma 5127 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5128 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5129 
    args.read(iprot)
5130 
    iprot.readMessageEnd()
5131 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5132 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5133 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
5137 
 
2536 chandransh 5138 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5139 
    args = toggleDOAFlag_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = toggleDOAFlag_result()
5143 
    try:
5144 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5145 
    except TransactionServiceException, ex:
5146 
      result.ex = ex
5147 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
1886 ankur.sing 5151 
 
4712 rajveer 5152 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5153 
    args = markOrderAsDelivered_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = markOrderAsDelivered_result()
5157 
    try:
5158 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5159 
    except TransactionServiceException, ex:
5160 
      result.ex = ex
5161 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
4454 rajveer 5166 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5167 
    args = markOrderDoaRequestReceived_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = markOrderDoaRequestReceived_result()
5171 
    try:
5172 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5173 
    except TransactionServiceException, ex:
5174 
      result.ex = ex
5175 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
5180 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5181 
    args = markOrderDoaRequestAuthorized_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = markOrderDoaRequestAuthorized_result()
5185 
    try:
5186 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5187 
    except TransactionServiceException, ex:
5188 
      result.ex = ex
5189 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
5193 
 
4488 rajveer 5194 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5195 
    args = markOrderReturnRequestReceived_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = markOrderReturnRequestReceived_result()
5199 
    try:
5200 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5201 
    except TransactionServiceException, ex:
5202 
      result.ex = ex
5203 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5204 
    result.write(oprot)
5205 
    oprot.writeMessageEnd()
5206 
    oprot.trans.flush()
5207 
 
5208 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5209 
    args = markOrderReturnRequestAuthorized_args()
5210 
    args.read(iprot)
5211 
    iprot.readMessageEnd()
5212 
    result = markOrderReturnRequestAuthorized_result()
5213 
    try:
5214 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5215 
    except TransactionServiceException, ex:
5216 
      result.ex = ex
5217 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5218 
    result.write(oprot)
5219 
    oprot.writeMessageEnd()
5220 
    oprot.trans.flush()
5221 
 
2536 chandransh 5222 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5223 
    args = requestPickupNumber_args()
5224 
    args.read(iprot)
5225 
    iprot.readMessageEnd()
5226 
    result = requestPickupNumber_result()
5227 
    try:
4579 rajveer 5228 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5229 
    except TransactionServiceException, ex:
5230 
      result.ex = ex
5231 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5232 
    result.write(oprot)
5233 
    oprot.writeMessageEnd()
5234 
    oprot.trans.flush()
5235 
 
5236 
  def process_authorizePickup(self, seqid, iprot, oprot):
5237 
    args = authorizePickup_args()
5238 
    args.read(iprot)
5239 
    iprot.readMessageEnd()
5240 
    result = authorizePickup_result()
5241 
    try:
4602 rajveer 5242 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5243 
    except TransactionServiceException, ex:
5244 
      result.ex = ex
5245 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5246 
    result.write(oprot)
5247 
    oprot.writeMessageEnd()
5248 
    oprot.trans.flush()
5249 
 
2764 chandransh 5250 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5251 
    args = markDoasAsPickedUp_args()
5252 
    args.read(iprot)
5253 
    iprot.readMessageEnd()
5254 
    result = markDoasAsPickedUp_result()
5255 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5256 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5257 
    result.write(oprot)
5258 
    oprot.writeMessageEnd()
5259 
    oprot.trans.flush()
5260 
 
4741 phani.kuma 5261 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5262 
    args = markReturnOrdersAsPickedUp_args()
5263 
    args.read(iprot)
5264 
    iprot.readMessageEnd()
5265 
    result = markReturnOrdersAsPickedUp_result()
5266 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5267 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
5271 
 
2616 chandransh 5272 
  def process_receiveReturn(self, seqid, iprot, oprot):
5273 
    args = receiveReturn_args()
2591 chandransh 5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
2616 chandransh 5276 
    result = receiveReturn_result()
2591 chandransh 5277 
    try:
4479 rajveer 5278 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
2616 chandransh 5281 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
2536 chandransh 5285 
 
2591 chandransh 5286 
  def process_validateDoa(self, seqid, iprot, oprot):
5287 
    args = validateDoa_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = validateDoa_result()
5291 
    try:
5292 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5293 
    except TransactionServiceException, ex:
5294 
      result.ex = ex
5295 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
5299 
 
4495 rajveer 5300 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5301 
    args = validateReturnProduct_args()
5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
5304 
    result = validateReturnProduct_result()
5305 
    try:
5306 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5307 
    except TransactionServiceException, ex:
5308 
      result.ex = ex
5309 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
5313 
 
2616 chandransh 5314 
  def process_reshipOrder(self, seqid, iprot, oprot):
5315 
    args = reshipOrder_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = reshipOrder_result()
5319 
    try:
5320 
      result.success = self._handler.reshipOrder(args.orderId)
5321 
    except TransactionServiceException, ex:
5322 
      result.ex = ex
5323 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5324 
    result.write(oprot)
5325 
    oprot.writeMessageEnd()
5326 
    oprot.trans.flush()
2591 chandransh 5327 
 
2616 chandransh 5328 
  def process_refundOrder(self, seqid, iprot, oprot):
5329 
    args = refundOrder_args()
5330 
    args.read(iprot)
5331 
    iprot.readMessageEnd()
5332 
    result = refundOrder_result()
5333 
    try:
3226 chandransh 5334 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5335 
    except TransactionServiceException, ex:
5336 
      result.ex = ex
5337 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5338 
    result.write(oprot)
5339 
    oprot.writeMessageEnd()
5340 
    oprot.trans.flush()
5341 
 
2690 chandransh 5342 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5343 
    args = getReturnOrders_args()
5344 
    args.read(iprot)
5345 
    iprot.readMessageEnd()
5346 
    result = getReturnOrders_result()
5347 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5348 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5349 
    result.write(oprot)
5350 
    oprot.writeMessageEnd()
5351 
    oprot.trans.flush()
2616 chandransh 5352 
 
2700 chandransh 5353 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5354 
    args = getReturnOrder_args()
5355 
    args.read(iprot)
5356 
    iprot.readMessageEnd()
5357 
    result = getReturnOrder_result()
5358 
    try:
5359 
      result.success = self._handler.getReturnOrder(args.id)
5360 
    except TransactionServiceException, ex:
5361 
      result.ex = ex
5362 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5363 
    result.write(oprot)
5364 
    oprot.writeMessageEnd()
5365 
    oprot.trans.flush()
5366 
 
2690 chandransh 5367 
  def process_processReturn(self, seqid, iprot, oprot):
5368 
    args = processReturn_args()
5369 
    args.read(iprot)
5370 
    iprot.readMessageEnd()
5371 
    result = processReturn_result()
5372 
    try:
5373 
      self._handler.processReturn(args.returnOrderId)
5374 
    except TransactionServiceException, ex:
5375 
      result.ex = ex
5376 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5377 
    result.write(oprot)
5378 
    oprot.writeMessageEnd()
5379 
    oprot.trans.flush()
5380 
 
3451 chandransh 5381 
  def process_updateWeight(self, seqid, iprot, oprot):
5382 
    args = updateWeight_args()
5383 
    args.read(iprot)
5384 
    iprot.readMessageEnd()
5385 
    result = updateWeight_result()
5386 
    try:
5387 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5388 
    except TransactionServiceException, ex:
5389 
      result.ex = ex
5390 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
2819 chandransh 5394 
 
3469 chandransh 5395 
  def process_changeItem(self, seqid, iprot, oprot):
5396 
    args = changeItem_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = changeItem_result()
5400 
    try:
5401 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5402 
    except TransactionServiceException, ex:
5403 
      result.ex = ex
5404 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5405 
    result.write(oprot)
5406 
    oprot.writeMessageEnd()
5407 
    oprot.trans.flush()
3451 chandransh 5408 
 
3469 chandransh 5409 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5410 
    args = shiftToWarehouse_args()
5411 
    args.read(iprot)
5412 
    iprot.readMessageEnd()
5413 
    result = shiftToWarehouse_result()
5414 
    try:
5415 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5416 
    except TransactionServiceException, ex:
5417 
      result.ex = ex
5418 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5419 
    result.write(oprot)
5420 
    oprot.writeMessageEnd()
5421 
    oprot.trans.flush()
5422 
 
3553 chandransh 5423 
  def process_addDelayReason(self, seqid, iprot, oprot):
5424 
    args = addDelayReason_args()
5425 
    args.read(iprot)
5426 
    iprot.readMessageEnd()
5427 
    result = addDelayReason_result()
5428 
    try:
4647 rajveer 5429 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5430 
    except TransactionServiceException, ex:
5431 
      result.ex = ex
5432 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5433 
    result.write(oprot)
5434 
    oprot.writeMessageEnd()
5435 
    oprot.trans.flush()
3469 chandransh 5436 
 
3956 chandransh 5437 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5438 
    args = reconcileCodCollection_args()
5439 
    args.read(iprot)
5440 
    iprot.readMessageEnd()
5441 
    result = reconcileCodCollection_result()
5442 
    try:
5443 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5444 
    except TransactionServiceException, ex:
5445 
      result.ex = ex
5446 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5447 
    result.write(oprot)
5448 
    oprot.writeMessageEnd()
5449 
    oprot.trans.flush()
3553 chandransh 5450 
 
4008 mandeep.dh 5451 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5452 
    args = getTransactionsRequiringExtraProcessing_args()
5453 
    args.read(iprot)
5454 
    iprot.readMessageEnd()
5455 
    result = getTransactionsRequiringExtraProcessing_result()
5456 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5457 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5458 
    result.write(oprot)
5459 
    oprot.writeMessageEnd()
5460 
    oprot.trans.flush()
3956 chandransh 5461 
 
4008 mandeep.dh 5462 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5463 
    args = markTransactionAsProcessed_args()
5464 
    args.read(iprot)
5465 
    iprot.readMessageEnd()
5466 
    result = markTransactionAsProcessed_result()
5467 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5468 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5469 
    result.write(oprot)
5470 
    oprot.writeMessageEnd()
5471 
    oprot.trans.flush()
5472 
 
4018 chandransh 5473 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5474 
    args = getItemWiseRiskyOrdersCount_args()
5475 
    args.read(iprot)
5476 
    iprot.readMessageEnd()
5477 
    result = getItemWiseRiskyOrdersCount_result()
5478 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5479 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5480 
    result.write(oprot)
5481 
    oprot.writeMessageEnd()
5482 
    oprot.trans.flush()
4008 mandeep.dh 5483 
 
4295 varun.gupt 5484 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5485 
    args = getOrdersForItemIds_args()
5486 
    args.read(iprot)
5487 
    iprot.readMessageEnd()
5488 
    result = getOrdersForItemIds_result()
5489 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5490 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5491 
    result.write(oprot)
5492 
    oprot.writeMessageEnd()
5493 
    oprot.trans.flush()
5494 
 
4247 rajveer 5495 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5496 
    args = markOrderCancellationRequestReceived_args()
5497 
    args.read(iprot)
5498 
    iprot.readMessageEnd()
5499 
    result = markOrderCancellationRequestReceived_result()
5500 
    try:
5501 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5502 
    except TransactionServiceException, ex:
5503 
      result.ex = ex
5504 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5505 
    result.write(oprot)
5506 
    oprot.writeMessageEnd()
5507 
    oprot.trans.flush()
4018 chandransh 5508 
 
4247 rajveer 5509 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5510 
    args = markOrderCancellationRequestConfirmed_args()
5511 
    args.read(iprot)
5512 
    iprot.readMessageEnd()
5513 
    result = markOrderCancellationRequestConfirmed_result()
5514 
    try:
5515 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5516 
    except TransactionServiceException, ex:
5517 
      result.ex = ex
5518 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5519 
    result.write(oprot)
5520 
    oprot.writeMessageEnd()
5521 
    oprot.trans.flush()
5522 
 
5523 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5524 
    args = markOrderCancellationRequestDenied_args()
5525 
    args.read(iprot)
5526 
    iprot.readMessageEnd()
5527 
    result = markOrderCancellationRequestDenied_result()
5528 
    try:
5529 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5530 
    except TransactionServiceException, ex:
5531 
      result.ex = ex
5532 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5533 
    result.write(oprot)
5534 
    oprot.writeMessageEnd()
5535 
    oprot.trans.flush()
5536 
 
4258 rajveer 5537 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5538 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5539 
    args.read(iprot)
5540 
    iprot.readMessageEnd()
4258 rajveer 5541 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5542 
    try:
4258 rajveer 5543 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5544 
    except TransactionServiceException, ex:
5545 
      result.ex = ex
4258 rajveer 5546 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5547 
    result.write(oprot)
5548 
    oprot.writeMessageEnd()
5549 
    oprot.trans.flush()
5550 
 
4259 anupam.sin 5551 
  def process_refundTransaction(self, seqid, iprot, oprot):
5552 
    args = refundTransaction_args()
5553 
    args.read(iprot)
5554 
    iprot.readMessageEnd()
5555 
    result = refundTransaction_result()
5556 
    try:
5557 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5558 
    except TransactionServiceException, ex:
5559 
      result.ex = ex
5560 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5561 
    result.write(oprot)
5562 
    oprot.writeMessageEnd()
5563 
    oprot.trans.flush()
4247 rajveer 5564 
 
4324 mandeep.dh 5565 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5566 
    args = updateShipmentAddress_args()
5567 
    args.read(iprot)
5568 
    iprot.readMessageEnd()
5569 
    result = updateShipmentAddress_result()
5570 
    try:
5571 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5572 
    except TransactionServiceException, ex:
5573 
      result.ex = ex
5574 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5575 
    result.write(oprot)
5576 
    oprot.writeMessageEnd()
5577 
    oprot.trans.flush()
5578 
 
4285 rajveer 5579 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5580 
    args = acceptOrdersForItemId_args()
5581 
    args.read(iprot)
5582 
    iprot.readMessageEnd()
5583 
    result = acceptOrdersForItemId_result()
5584 
    try:
5585 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5586 
    except TransactionServiceException, ex:
5587 
      result.ex = ex
5588 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
4259 anupam.sin 5592 
 
4303 rajveer 5593 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5594 
    args = markOrdersAsPORaised_args()
5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
5597 
    result = markOrdersAsPORaised_result()
5598 
    try:
4369 rajveer 5599 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5600 
    except TransactionServiceException, ex:
5601 
      result.ex = ex
5602 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
4285 rajveer 5606 
 
4303 rajveer 5607 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5608 
    args = markOrdersAsReversalInitiated_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = markOrdersAsReversalInitiated_result()
5612 
    try:
4369 rajveer 5613 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5614 
    except TransactionServiceException, ex:
5615 
      result.ex = ex
5616 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
5621 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5622 
    args = markOrdersAsNotAvailabke_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = markOrdersAsNotAvailabke_result()
5626 
    try:
4369 rajveer 5627 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5628 
    except TransactionServiceException, ex:
5629 
      result.ex = ex
5630 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
4369 rajveer 5635 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5636 
    args = markOrdersAsTimeout_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = markOrdersAsTimeout_result()
5640 
    try:
5641 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5642 
    except TransactionServiceException, ex:
5643 
      result.ex = ex
5644 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
4303 rajveer 5648 
 
4662 rajveer 5649 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5650 
    args = markOrderAsLostInTransit_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = markOrderAsLostInTransit_result()
5654 
    try:
5655 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5656 
    except TransactionServiceException, ex:
5657 
      result.ex = ex
5658 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
4386 anupam.sin 5663 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5664 
    args = getOrderForAwb_args()
5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
5667 
    result = getOrderForAwb_result()
5668 
    try:
5669 
      result.success = self._handler.getOrderForAwb(args.awb)
5670 
    except TransactionServiceException, ex:
5671 
      result.ex = ex
5672 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
4369 rajveer 5676 
 
4506 phani.kuma 5677 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5678 
    args = getOrdersForProviderForStatus_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = getOrdersForProviderForStatus_result()
5682 
    try:
5683 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5684 
    except TransactionServiceException, ex:
5685 
      result.ex = ex
5686 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
4386 anupam.sin 5690 
 
4600 varun.gupt 5691 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5692 
    args = getBilledOrdersForVendor_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = getBilledOrdersForVendor_result()
5696 
    try:
5697 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5698 
    except TransactionServiceException, ex:
5699 
      result.ex = ex
5700 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
4506 phani.kuma 5704 
 
4607 rajveer 5705 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5706 
    args = getSlippedSippingDateOrders_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = getSlippedSippingDateOrders_result()
5710 
    try:
5711 
      result.success = self._handler.getSlippedSippingDateOrders()
5712 
    except TransactionServiceException, ex:
5713 
      result.ex = ex
5714 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
5718 
 
4709 rajveer 5719 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5720 
    args = getCancelledOrders_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = getCancelledOrders_result()
5724 
    try:
5725 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5726 
    except TransactionServiceException, ex:
5727 
      result.ex = ex
5728 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
4600 varun.gupt 5733 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5734 
    args = saveBluedartSettlements_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = saveBluedartSettlements_result()
5738 
    try:
5739 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5740 
    except TransactionServiceException, ex:
5741 
      result.ex = ex
5742 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5743 
    result.write(oprot)
5744 
    oprot.writeMessageEnd()
5745 
    oprot.trans.flush()
5746 
 
5747 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5748 
    args = savePaymentSettlements_args()
5749 
    args.read(iprot)
5750 
    iprot.readMessageEnd()
5751 
    result = savePaymentSettlements_result()
5752 
    try:
5753 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5754 
    except TransactionServiceException, ex:
5755 
      result.ex = ex
5756 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5757 
    result.write(oprot)
5758 
    oprot.writeMessageEnd()
5759 
    oprot.trans.flush()
5760 
 
5761 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5762 
    args = saveEBSSettlementSummary_args()
5763 
    args.read(iprot)
5764 
    iprot.readMessageEnd()
5765 
    result = saveEBSSettlementSummary_result()
5766 
    try:
5767 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5768 
    except TransactionServiceException, ex:
5769 
      result.ex = ex
5770 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5771 
    result.write(oprot)
5772 
    oprot.writeMessageEnd()
5773 
    oprot.trans.flush()
5774 
 
5775 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5776 
    args = getSettlementForPaymentId_args()
5777 
    args.read(iprot)
5778 
    iprot.readMessageEnd()
5779 
    result = getSettlementForPaymentId_result()
5780 
    try:
5781 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5782 
    except TransactionServiceException, ex:
5783 
      result.ex = ex
5784 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5785 
    result.write(oprot)
5786 
    oprot.writeMessageEnd()
5787 
    oprot.trans.flush()
5788 
 
5789 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5790 
    args = getEBSSettlementSummaries_args()
5791 
    args.read(iprot)
5792 
    iprot.readMessageEnd()
5793 
    result = getEBSSettlementSummaries_result()
5794 
    try:
5795 
      result.success = self._handler.getEBSSettlementSummaries()
5796 
    except TransactionServiceException, ex:
5797 
      result.ex = ex
5798 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5799 
    result.write(oprot)
5800 
    oprot.writeMessageEnd()
5801 
    oprot.trans.flush()
5802 
 
5803 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5804 
    args = markEBSSettlementUploaded_args()
5805 
    args.read(iprot)
5806 
    iprot.readMessageEnd()
5807 
    result = markEBSSettlementUploaded_result()
5808 
    try:
5809 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5810 
    except TransactionServiceException, ex:
5811 
      result.ex = ex
5812 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5813 
    result.write(oprot)
5814 
    oprot.writeMessageEnd()
5815 
    oprot.trans.flush()
5816 
 
5817 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5818 
    args = getEBSSettlementDate_args()
5819 
    args.read(iprot)
5820 
    iprot.readMessageEnd()
5821 
    result = getEBSSettlementDate_result()
5822 
    try:
5823 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5824 
    except TransactionServiceException, ex:
5825 
      result.ex = ex
5826 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5827 
    result.write(oprot)
5828 
    oprot.writeMessageEnd()
5829 
    oprot.trans.flush()
5830 
 
4715 varun.gupt 5831 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5832 
    args = getSettlementsByDate_args()
5833 
    args.read(iprot)
5834 
    iprot.readMessageEnd()
5835 
    result = getSettlementsByDate_result()
5836 
    try:
5837 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5838 
    except TransactionServiceException, ex:
5839 
      result.ex = ex
5840 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5841 
    result.write(oprot)
5842 
    oprot.writeMessageEnd()
5843 
    oprot.trans.flush()
4600 varun.gupt 5844 
 
4715 varun.gupt 5845 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5846 
    args = getReshippedOrderIds_args()
5847 
    args.read(iprot)
5848 
    iprot.readMessageEnd()
5849 
    result = getReshippedOrderIds_result()
5850 
    try:
5851 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5852 
    except TransactionServiceException, ex:
5853 
      result.ex = ex
5854 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5855 
    result.write(oprot)
5856 
    oprot.writeMessageEnd()
5857 
    oprot.trans.flush()
5858 
 
4757 mandeep.dh 5859 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5860 
    args = updateOrdersAsPORaised_args()
5861 
    args.read(iprot)
5862 
    iprot.readMessageEnd()
5863 
    result = updateOrdersAsPORaised_result()
5864 
    try:
5865 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5866 
    except TransactionServiceException, ex:
5867 
      result.ex = ex
5868 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
4715 varun.gupt 5872 
 
4757 mandeep.dh 5873 
 
94 ashish 5874 
# HELPER FUNCTIONS AND STRUCTURES
5875 
 
5876 
class createTransaction_args:
5877 
  """
5878 
  Attributes:
5879 
   - transaction
5880 
  """
5881 
 
5882 
  thrift_spec = (
5883 
    None, # 0
5884 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5885 
  )
5886 
 
5887 
  def __init__(self, transaction=None,):
5888 
    self.transaction = transaction
5889 
 
5890 
  def read(self, iprot):
5891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5893 
      return
5894 
    iprot.readStructBegin()
5895 
    while True:
5896 
      (fname, ftype, fid) = iprot.readFieldBegin()
5897 
      if ftype == TType.STOP:
5898 
        break
5899 
      if fid == 1:
5900 
        if ftype == TType.STRUCT:
5901 
          self.transaction = Transaction()
5902 
          self.transaction.read(iprot)
5903 
        else:
5904 
          iprot.skip(ftype)
5905 
      else:
5906 
        iprot.skip(ftype)
5907 
      iprot.readFieldEnd()
5908 
    iprot.readStructEnd()
5909 
 
5910 
  def write(self, oprot):
5911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5913 
      return
5914 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5915 
    if self.transaction is not None:
94 ashish 5916 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5917 
      self.transaction.write(oprot)
5918 
      oprot.writeFieldEnd()
5919 
    oprot.writeFieldStop()
5920 
    oprot.writeStructEnd()
5921 
 
3431 rajveer 5922 
  def validate(self):
5923 
    return
5924 
 
5925 
 
94 ashish 5926 
  def __repr__(self):
5927 
    L = ['%s=%r' % (key, value)
5928 
      for key, value in self.__dict__.iteritems()]
5929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5930 
 
5931 
  def __eq__(self, other):
5932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5933 
 
5934 
  def __ne__(self, other):
5935 
    return not (self == other)
5936 
 
5937 
class createTransaction_result:
5938 
  """
5939 
  Attributes:
132 ashish 5940 
   - success
94 ashish 5941 
   - ex
5942 
  """
5943 
 
5944 
  thrift_spec = (
132 ashish 5945 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5947 
  )
5948 
 
132 ashish 5949 
  def __init__(self, success=None, ex=None,):
5950 
    self.success = success
94 ashish 5951 
    self.ex = ex
5952 
 
5953 
  def read(self, iprot):
5954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5956 
      return
5957 
    iprot.readStructBegin()
5958 
    while True:
5959 
      (fname, ftype, fid) = iprot.readFieldBegin()
5960 
      if ftype == TType.STOP:
5961 
        break
132 ashish 5962 
      if fid == 0:
5963 
        if ftype == TType.I64:
5964 
          self.success = iprot.readI64();
5965 
        else:
5966 
          iprot.skip(ftype)
5967 
      elif fid == 1:
94 ashish 5968 
        if ftype == TType.STRUCT:
5969 
          self.ex = TransactionServiceException()
5970 
          self.ex.read(iprot)
5971 
        else:
5972 
          iprot.skip(ftype)
5973 
      else:
5974 
        iprot.skip(ftype)
5975 
      iprot.readFieldEnd()
5976 
    iprot.readStructEnd()
5977 
 
5978 
  def write(self, oprot):
5979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5981 
      return
5982 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5983 
    if self.success is not None:
132 ashish 5984 
      oprot.writeFieldBegin('success', TType.I64, 0)
5985 
      oprot.writeI64(self.success)
5986 
      oprot.writeFieldEnd()
3431 rajveer 5987 
    if self.ex is not None:
94 ashish 5988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5989 
      self.ex.write(oprot)
5990 
      oprot.writeFieldEnd()
5991 
    oprot.writeFieldStop()
5992 
    oprot.writeStructEnd()
5993 
 
3431 rajveer 5994 
  def validate(self):
5995 
    return
5996 
 
5997 
 
94 ashish 5998 
  def __repr__(self):
5999 
    L = ['%s=%r' % (key, value)
6000 
      for key, value in self.__dict__.iteritems()]
6001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6002 
 
6003 
  def __eq__(self, other):
6004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6005 
 
6006 
  def __ne__(self, other):
6007 
    return not (self == other)
6008 
 
6009 
class getTransaction_args:
6010 
  """
6011 
  Attributes:
6012 
   - id
6013 
  """
6014 
 
6015 
  thrift_spec = (
6016 
    None, # 0
6017 
    (1, TType.I64, 'id', None, None, ), # 1
6018 
  )
6019 
 
6020 
  def __init__(self, id=None,):
6021 
    self.id = id
6022 
 
6023 
  def read(self, iprot):
6024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6026 
      return
6027 
    iprot.readStructBegin()
6028 
    while True:
6029 
      (fname, ftype, fid) = iprot.readFieldBegin()
6030 
      if ftype == TType.STOP:
6031 
        break
6032 
      if fid == 1:
6033 
        if ftype == TType.I64:
6034 
          self.id = iprot.readI64();
6035 
        else:
6036 
          iprot.skip(ftype)
6037 
      else:
6038 
        iprot.skip(ftype)
6039 
      iprot.readFieldEnd()
6040 
    iprot.readStructEnd()
6041 
 
6042 
  def write(self, oprot):
6043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6045 
      return
6046 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6047 
    if self.id is not None:
94 ashish 6048 
      oprot.writeFieldBegin('id', TType.I64, 1)
6049 
      oprot.writeI64(self.id)
6050 
      oprot.writeFieldEnd()
6051 
    oprot.writeFieldStop()
6052 
    oprot.writeStructEnd()
6053 
 
3431 rajveer 6054 
  def validate(self):
6055 
    return
6056 
 
6057 
 
94 ashish 6058 
  def __repr__(self):
6059 
    L = ['%s=%r' % (key, value)
6060 
      for key, value in self.__dict__.iteritems()]
6061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6062 
 
6063 
  def __eq__(self, other):
6064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6065 
 
6066 
  def __ne__(self, other):
6067 
    return not (self == other)
6068 
 
6069 
class getTransaction_result:
6070 
  """
6071 
  Attributes:
6072 
   - success
6073 
   - ex
6074 
  """
6075 
 
6076 
  thrift_spec = (
6077 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6079 
  )
6080 
 
6081 
  def __init__(self, success=None, ex=None,):
6082 
    self.success = success
6083 
    self.ex = ex
6084 
 
6085 
  def read(self, iprot):
6086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6088 
      return
6089 
    iprot.readStructBegin()
6090 
    while True:
6091 
      (fname, ftype, fid) = iprot.readFieldBegin()
6092 
      if ftype == TType.STOP:
6093 
        break
6094 
      if fid == 0:
6095 
        if ftype == TType.STRUCT:
6096 
          self.success = Transaction()
6097 
          self.success.read(iprot)
6098 
        else:
6099 
          iprot.skip(ftype)
6100 
      elif fid == 1:
6101 
        if ftype == TType.STRUCT:
6102 
          self.ex = TransactionServiceException()
6103 
          self.ex.read(iprot)
6104 
        else:
6105 
          iprot.skip(ftype)
6106 
      else:
6107 
        iprot.skip(ftype)
6108 
      iprot.readFieldEnd()
6109 
    iprot.readStructEnd()
6110 
 
6111 
  def write(self, oprot):
6112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6114 
      return
6115 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6116 
    if self.success is not None:
94 ashish 6117 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6118 
      self.success.write(oprot)
6119 
      oprot.writeFieldEnd()
3431 rajveer 6120 
    if self.ex is not None:
94 ashish 6121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6122 
      self.ex.write(oprot)
6123 
      oprot.writeFieldEnd()
6124 
    oprot.writeFieldStop()
6125 
    oprot.writeStructEnd()
6126 
 
3431 rajveer 6127 
  def validate(self):
6128 
    return
6129 
 
6130 
 
94 ashish 6131 
  def __repr__(self):
6132 
    L = ['%s=%r' % (key, value)
6133 
      for key, value in self.__dict__.iteritems()]
6134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6135 
 
6136 
  def __eq__(self, other):
6137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6138 
 
6139 
  def __ne__(self, other):
6140 
    return not (self == other)
6141 
 
6142 
class getTransactionsForCustomer_args:
6143 
  """
6144 
  Attributes:
6145 
   - customerId
6146 
   - from_date
6147 
   - to_date
6148 
   - status
6149 
  """
6150 
 
6151 
  thrift_spec = (
6152 
    None, # 0
6153 
    (1, TType.I64, 'customerId', None, None, ), # 1
6154 
    (2, TType.I64, 'from_date', None, None, ), # 2
6155 
    (3, TType.I64, 'to_date', None, None, ), # 3
6156 
    (4, TType.I32, 'status', None, None, ), # 4
6157 
  )
6158 
 
6159 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6160 
    self.customerId = customerId
6161 
    self.from_date = from_date
6162 
    self.to_date = to_date
6163 
    self.status = status
6164 
 
6165 
  def read(self, iprot):
6166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6168 
      return
6169 
    iprot.readStructBegin()
6170 
    while True:
6171 
      (fname, ftype, fid) = iprot.readFieldBegin()
6172 
      if ftype == TType.STOP:
6173 
        break
6174 
      if fid == 1:
6175 
        if ftype == TType.I64:
6176 
          self.customerId = iprot.readI64();
6177 
        else:
6178 
          iprot.skip(ftype)
6179 
      elif fid == 2:
6180 
        if ftype == TType.I64:
6181 
          self.from_date = iprot.readI64();
6182 
        else:
6183 
          iprot.skip(ftype)
6184 
      elif fid == 3:
6185 
        if ftype == TType.I64:
6186 
          self.to_date = iprot.readI64();
6187 
        else:
6188 
          iprot.skip(ftype)
6189 
      elif fid == 4:
6190 
        if ftype == TType.I32:
6191 
          self.status = iprot.readI32();
6192 
        else:
6193 
          iprot.skip(ftype)
6194 
      else:
6195 
        iprot.skip(ftype)
6196 
      iprot.readFieldEnd()
6197 
    iprot.readStructEnd()
6198 
 
6199 
  def write(self, oprot):
6200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6202 
      return
6203 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6204 
    if self.customerId is not None:
94 ashish 6205 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6206 
      oprot.writeI64(self.customerId)
6207 
      oprot.writeFieldEnd()
3431 rajveer 6208 
    if self.from_date is not None:
94 ashish 6209 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6210 
      oprot.writeI64(self.from_date)
6211 
      oprot.writeFieldEnd()
3431 rajveer 6212 
    if self.to_date is not None:
94 ashish 6213 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6214 
      oprot.writeI64(self.to_date)
6215 
      oprot.writeFieldEnd()
3431 rajveer 6216 
    if self.status is not None:
94 ashish 6217 
      oprot.writeFieldBegin('status', TType.I32, 4)
6218 
      oprot.writeI32(self.status)
6219 
      oprot.writeFieldEnd()
6220 
    oprot.writeFieldStop()
6221 
    oprot.writeStructEnd()
6222 
 
3431 rajveer 6223 
  def validate(self):
6224 
    return
6225 
 
6226 
 
94 ashish 6227 
  def __repr__(self):
6228 
    L = ['%s=%r' % (key, value)
6229 
      for key, value in self.__dict__.iteritems()]
6230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6231 
 
6232 
  def __eq__(self, other):
6233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6234 
 
6235 
  def __ne__(self, other):
6236 
    return not (self == other)
6237 
 
6238 
class getTransactionsForCustomer_result:
6239 
  """
6240 
  Attributes:
6241 
   - success
6242 
   - ex
6243 
  """
6244 
 
6245 
  thrift_spec = (
6246 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6248 
  )
6249 
 
6250 
  def __init__(self, success=None, ex=None,):
6251 
    self.success = success
6252 
    self.ex = ex
6253 
 
6254 
  def read(self, iprot):
6255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6257 
      return
6258 
    iprot.readStructBegin()
6259 
    while True:
6260 
      (fname, ftype, fid) = iprot.readFieldBegin()
6261 
      if ftype == TType.STOP:
6262 
        break
6263 
      if fid == 0:
6264 
        if ftype == TType.LIST:
6265 
          self.success = []
685 chandransh 6266 
          (_etype17, _size14) = iprot.readListBegin()
6267 
          for _i18 in xrange(_size14):
6268 
            _elem19 = Transaction()
6269 
            _elem19.read(iprot)
6270 
            self.success.append(_elem19)
94 ashish 6271 
          iprot.readListEnd()
6272 
        else:
6273 
          iprot.skip(ftype)
6274 
      elif fid == 1:
6275 
        if ftype == TType.STRUCT:
6276 
          self.ex = TransactionServiceException()
6277 
          self.ex.read(iprot)
6278 
        else:
6279 
          iprot.skip(ftype)
6280 
      else:
6281 
        iprot.skip(ftype)
6282 
      iprot.readFieldEnd()
6283 
    iprot.readStructEnd()
6284 
 
6285 
  def write(self, oprot):
6286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6288 
      return
6289 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6290 
    if self.success is not None:
94 ashish 6291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6293 
      for iter20 in self.success:
6294 
        iter20.write(oprot)
94 ashish 6295 
      oprot.writeListEnd()
6296 
      oprot.writeFieldEnd()
3431 rajveer 6297 
    if self.ex is not None:
94 ashish 6298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6299 
      self.ex.write(oprot)
6300 
      oprot.writeFieldEnd()
6301 
    oprot.writeFieldStop()
6302 
    oprot.writeStructEnd()
6303 
 
3431 rajveer 6304 
  def validate(self):
6305 
    return
6306 
 
6307 
 
94 ashish 6308 
  def __repr__(self):
6309 
    L = ['%s=%r' % (key, value)
6310 
      for key, value in self.__dict__.iteritems()]
6311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6312 
 
6313 
  def __eq__(self, other):
6314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6315 
 
6316 
  def __ne__(self, other):
6317 
    return not (self == other)
6318 
 
132 ashish 6319 
class getTransactionsForShoppingCartId_args:
6320 
  """
6321 
  Attributes:
6322 
   - shoppingCartId
6323 
  """
6324 
 
6325 
  thrift_spec = (
6326 
    None, # 0
6327 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6328 
  )
6329 
 
6330 
  def __init__(self, shoppingCartId=None,):
6331 
    self.shoppingCartId = shoppingCartId
6332 
 
6333 
  def read(self, iprot):
6334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6336 
      return
6337 
    iprot.readStructBegin()
6338 
    while True:
6339 
      (fname, ftype, fid) = iprot.readFieldBegin()
6340 
      if ftype == TType.STOP:
6341 
        break
6342 
      if fid == 1:
6343 
        if ftype == TType.I64:
6344 
          self.shoppingCartId = iprot.readI64();
6345 
        else:
6346 
          iprot.skip(ftype)
6347 
      else:
6348 
        iprot.skip(ftype)
6349 
      iprot.readFieldEnd()
6350 
    iprot.readStructEnd()
6351 
 
6352 
  def write(self, oprot):
6353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6355 
      return
6356 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6357 
    if self.shoppingCartId is not None:
132 ashish 6358 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6359 
      oprot.writeI64(self.shoppingCartId)
6360 
      oprot.writeFieldEnd()
6361 
    oprot.writeFieldStop()
6362 
    oprot.writeStructEnd()
6363 
 
3431 rajveer 6364 
  def validate(self):
6365 
    return
6366 
 
6367 
 
132 ashish 6368 
  def __repr__(self):
6369 
    L = ['%s=%r' % (key, value)
6370 
      for key, value in self.__dict__.iteritems()]
6371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6372 
 
6373 
  def __eq__(self, other):
6374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6375 
 
6376 
  def __ne__(self, other):
6377 
    return not (self == other)
6378 
 
6379 
class getTransactionsForShoppingCartId_result:
6380 
  """
6381 
  Attributes:
6382 
   - success
6383 
   - ex
6384 
  """
6385 
 
6386 
  thrift_spec = (
6387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6389 
  )
6390 
 
6391 
  def __init__(self, success=None, ex=None,):
6392 
    self.success = success
6393 
    self.ex = ex
6394 
 
6395 
  def read(self, iprot):
6396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6398 
      return
6399 
    iprot.readStructBegin()
6400 
    while True:
6401 
      (fname, ftype, fid) = iprot.readFieldBegin()
6402 
      if ftype == TType.STOP:
6403 
        break
6404 
      if fid == 0:
6405 
        if ftype == TType.LIST:
6406 
          self.success = []
685 chandransh 6407 
          (_etype24, _size21) = iprot.readListBegin()
6408 
          for _i25 in xrange(_size21):
6409 
            _elem26 = Transaction()
6410 
            _elem26.read(iprot)
6411 
            self.success.append(_elem26)
132 ashish 6412 
          iprot.readListEnd()
6413 
        else:
6414 
          iprot.skip(ftype)
6415 
      elif fid == 1:
6416 
        if ftype == TType.STRUCT:
6417 
          self.ex = TransactionServiceException()
6418 
          self.ex.read(iprot)
6419 
        else:
6420 
          iprot.skip(ftype)
6421 
      else:
6422 
        iprot.skip(ftype)
6423 
      iprot.readFieldEnd()
6424 
    iprot.readStructEnd()
6425 
 
6426 
  def write(self, oprot):
6427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6429 
      return
6430 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6431 
    if self.success is not None:
132 ashish 6432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6434 
      for iter27 in self.success:
6435 
        iter27.write(oprot)
132 ashish 6436 
      oprot.writeListEnd()
6437 
      oprot.writeFieldEnd()
3431 rajveer 6438 
    if self.ex is not None:
132 ashish 6439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6440 
      self.ex.write(oprot)
6441 
      oprot.writeFieldEnd()
6442 
    oprot.writeFieldStop()
6443 
    oprot.writeStructEnd()
6444 
 
3431 rajveer 6445 
  def validate(self):
6446 
    return
6447 
 
6448 
 
132 ashish 6449 
  def __repr__(self):
6450 
    L = ['%s=%r' % (key, value)
6451 
      for key, value in self.__dict__.iteritems()]
6452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6453 
 
6454 
  def __eq__(self, other):
6455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6456 
 
6457 
  def __ne__(self, other):
6458 
    return not (self == other)
6459 
 
94 ashish 6460 
class getTransactionStatus_args:
6461 
  """
6462 
  Attributes:
6463 
   - transactionId
6464 
  """
6465 
 
6466 
  thrift_spec = (
6467 
    None, # 0
6468 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6469 
  )
6470 
 
6471 
  def __init__(self, transactionId=None,):
6472 
    self.transactionId = transactionId
6473 
 
6474 
  def read(self, iprot):
6475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6477 
      return
6478 
    iprot.readStructBegin()
6479 
    while True:
6480 
      (fname, ftype, fid) = iprot.readFieldBegin()
6481 
      if ftype == TType.STOP:
6482 
        break
6483 
      if fid == 1:
6484 
        if ftype == TType.I64:
6485 
          self.transactionId = iprot.readI64();
6486 
        else:
6487 
          iprot.skip(ftype)
6488 
      else:
6489 
        iprot.skip(ftype)
6490 
      iprot.readFieldEnd()
6491 
    iprot.readStructEnd()
6492 
 
6493 
  def write(self, oprot):
6494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6496 
      return
6497 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6498 
    if self.transactionId is not None:
94 ashish 6499 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6500 
      oprot.writeI64(self.transactionId)
6501 
      oprot.writeFieldEnd()
6502 
    oprot.writeFieldStop()
6503 
    oprot.writeStructEnd()
6504 
 
3431 rajveer 6505 
  def validate(self):
6506 
    return
6507 
 
6508 
 
94 ashish 6509 
  def __repr__(self):
6510 
    L = ['%s=%r' % (key, value)
6511 
      for key, value in self.__dict__.iteritems()]
6512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6513 
 
6514 
  def __eq__(self, other):
6515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6516 
 
6517 
  def __ne__(self, other):
6518 
    return not (self == other)
6519 
 
6520 
class getTransactionStatus_result:
6521 
  """
6522 
  Attributes:
6523 
   - success
6524 
   - ex
6525 
  """
6526 
 
6527 
  thrift_spec = (
6528 
    (0, TType.I32, 'success', None, None, ), # 0
6529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6530 
  )
6531 
 
6532 
  def __init__(self, success=None, ex=None,):
6533 
    self.success = success
6534 
    self.ex = ex
6535 
 
6536 
  def read(self, iprot):
6537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6539 
      return
6540 
    iprot.readStructBegin()
6541 
    while True:
6542 
      (fname, ftype, fid) = iprot.readFieldBegin()
6543 
      if ftype == TType.STOP:
6544 
        break
6545 
      if fid == 0:
6546 
        if ftype == TType.I32:
6547 
          self.success = iprot.readI32();
6548 
        else:
6549 
          iprot.skip(ftype)
6550 
      elif fid == 1:
6551 
        if ftype == TType.STRUCT:
6552 
          self.ex = TransactionServiceException()
6553 
          self.ex.read(iprot)
6554 
        else:
6555 
          iprot.skip(ftype)
6556 
      else:
6557 
        iprot.skip(ftype)
6558 
      iprot.readFieldEnd()
6559 
    iprot.readStructEnd()
6560 
 
6561 
  def write(self, oprot):
6562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6564 
      return
6565 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6566 
    if self.success is not None:
94 ashish 6567 
      oprot.writeFieldBegin('success', TType.I32, 0)
6568 
      oprot.writeI32(self.success)
6569 
      oprot.writeFieldEnd()
3431 rajveer 6570 
    if self.ex is not None:
94 ashish 6571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6572 
      self.ex.write(oprot)
6573 
      oprot.writeFieldEnd()
6574 
    oprot.writeFieldStop()
6575 
    oprot.writeStructEnd()
6576 
 
3431 rajveer 6577 
  def validate(self):
6578 
    return
6579 
 
6580 
 
94 ashish 6581 
  def __repr__(self):
6582 
    L = ['%s=%r' % (key, value)
6583 
      for key, value in self.__dict__.iteritems()]
6584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6585 
 
6586 
  def __eq__(self, other):
6587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6588 
 
6589 
  def __ne__(self, other):
6590 
    return not (self == other)
6591 
 
6592 
class changeTransactionStatus_args:
6593 
  """
6594 
  Attributes:
6595 
   - transactionId
6596 
   - status
6597 
   - description
6598 
  """
6599 
 
6600 
  thrift_spec = (
6601 
    None, # 0
6602 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6603 
    (2, TType.I32, 'status', None, None, ), # 2
6604 
    (3, TType.STRING, 'description', None, None, ), # 3
6605 
  )
6606 
 
6607 
  def __init__(self, transactionId=None, status=None, description=None,):
6608 
    self.transactionId = transactionId
6609 
    self.status = status
6610 
    self.description = description
6611 
 
6612 
  def read(self, iprot):
6613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6615 
      return
6616 
    iprot.readStructBegin()
6617 
    while True:
6618 
      (fname, ftype, fid) = iprot.readFieldBegin()
6619 
      if ftype == TType.STOP:
6620 
        break
6621 
      if fid == 1:
6622 
        if ftype == TType.I64:
6623 
          self.transactionId = iprot.readI64();
6624 
        else:
6625 
          iprot.skip(ftype)
6626 
      elif fid == 2:
6627 
        if ftype == TType.I32:
6628 
          self.status = iprot.readI32();
6629 
        else:
6630 
          iprot.skip(ftype)
6631 
      elif fid == 3:
6632 
        if ftype == TType.STRING:
6633 
          self.description = iprot.readString();
6634 
        else:
6635 
          iprot.skip(ftype)
6636 
      else:
6637 
        iprot.skip(ftype)
6638 
      iprot.readFieldEnd()
6639 
    iprot.readStructEnd()
6640 
 
6641 
  def write(self, oprot):
6642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6644 
      return
6645 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6646 
    if self.transactionId is not None:
94 ashish 6647 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6648 
      oprot.writeI64(self.transactionId)
6649 
      oprot.writeFieldEnd()
3431 rajveer 6650 
    if self.status is not None:
94 ashish 6651 
      oprot.writeFieldBegin('status', TType.I32, 2)
6652 
      oprot.writeI32(self.status)
6653 
      oprot.writeFieldEnd()
3431 rajveer 6654 
    if self.description is not None:
94 ashish 6655 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6656 
      oprot.writeString(self.description)
6657 
      oprot.writeFieldEnd()
6658 
    oprot.writeFieldStop()
6659 
    oprot.writeStructEnd()
6660 
 
3431 rajveer 6661 
  def validate(self):
6662 
    return
6663 
 
6664 
 
94 ashish 6665 
  def __repr__(self):
6666 
    L = ['%s=%r' % (key, value)
6667 
      for key, value in self.__dict__.iteritems()]
6668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6669 
 
6670 
  def __eq__(self, other):
6671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6672 
 
6673 
  def __ne__(self, other):
6674 
    return not (self == other)
6675 
 
6676 
class changeTransactionStatus_result:
6677 
  """
6678 
  Attributes:
6679 
   - success
6680 
   - ex
6681 
  """
6682 
 
6683 
  thrift_spec = (
6684 
    (0, TType.BOOL, 'success', None, None, ), # 0
6685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6686 
  )
6687 
 
6688 
  def __init__(self, success=None, ex=None,):
6689 
    self.success = success
6690 
    self.ex = ex
6691 
 
6692 
  def read(self, iprot):
6693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6695 
      return
6696 
    iprot.readStructBegin()
6697 
    while True:
6698 
      (fname, ftype, fid) = iprot.readFieldBegin()
6699 
      if ftype == TType.STOP:
6700 
        break
6701 
      if fid == 0:
6702 
        if ftype == TType.BOOL:
6703 
          self.success = iprot.readBool();
6704 
        else:
6705 
          iprot.skip(ftype)
6706 
      elif fid == 1:
6707 
        if ftype == TType.STRUCT:
6708 
          self.ex = TransactionServiceException()
6709 
          self.ex.read(iprot)
6710 
        else:
6711 
          iprot.skip(ftype)
6712 
      else:
6713 
        iprot.skip(ftype)
6714 
      iprot.readFieldEnd()
6715 
    iprot.readStructEnd()
6716 
 
6717 
  def write(self, oprot):
6718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6720 
      return
6721 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6722 
    if self.success is not None:
94 ashish 6723 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6724 
      oprot.writeBool(self.success)
6725 
      oprot.writeFieldEnd()
3431 rajveer 6726 
    if self.ex is not None:
94 ashish 6727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6728 
      self.ex.write(oprot)
6729 
      oprot.writeFieldEnd()
6730 
    oprot.writeFieldStop()
6731 
    oprot.writeStructEnd()
6732 
 
3431 rajveer 6733 
  def validate(self):
6734 
    return
6735 
 
6736 
 
94 ashish 6737 
  def __repr__(self):
6738 
    L = ['%s=%r' % (key, value)
6739 
      for key, value in self.__dict__.iteritems()]
6740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6741 
 
6742 
  def __eq__(self, other):
6743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6744 
 
6745 
  def __ne__(self, other):
6746 
    return not (self == other)
6747 
 
1398 varun.gupt 6748 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6749 
  """
6750 
  Attributes:
6751 
   - transactionId
6752 
  """
6753 
 
6754 
  thrift_spec = (
6755 
    None, # 0
6756 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6757 
  )
6758 
 
6759 
  def __init__(self, transactionId=None,):
6760 
    self.transactionId = transactionId
6761 
 
6762 
  def read(self, iprot):
6763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6765 
      return
6766 
    iprot.readStructBegin()
6767 
    while True:
6768 
      (fname, ftype, fid) = iprot.readFieldBegin()
6769 
      if ftype == TType.STOP:
6770 
        break
6771 
      if fid == 1:
6772 
        if ftype == TType.I64:
6773 
          self.transactionId = iprot.readI64();
6774 
        else:
6775 
          iprot.skip(ftype)
6776 
      else:
6777 
        iprot.skip(ftype)
6778 
      iprot.readFieldEnd()
6779 
    iprot.readStructEnd()
6780 
 
6781 
  def write(self, oprot):
6782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6784 
      return
1398 varun.gupt 6785 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6786 
    if self.transactionId is not None:
1382 varun.gupt 6787 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6788 
      oprot.writeI64(self.transactionId)
6789 
      oprot.writeFieldEnd()
6790 
    oprot.writeFieldStop()
6791 
    oprot.writeStructEnd()
6792 
 
3431 rajveer 6793 
  def validate(self):
6794 
    return
6795 
 
6796 
 
1382 varun.gupt 6797 
  def __repr__(self):
6798 
    L = ['%s=%r' % (key, value)
6799 
      for key, value in self.__dict__.iteritems()]
6800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6801 
 
6802 
  def __eq__(self, other):
6803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6804 
 
6805 
  def __ne__(self, other):
6806 
    return not (self == other)
6807 
 
1398 varun.gupt 6808 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6809 
  """
6810 
  Attributes:
6811 
   - success
6812 
   - ex
6813 
  """
6814 
 
6815 
  thrift_spec = (
6816 
    (0, TType.BOOL, 'success', None, None, ), # 0
6817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6818 
  )
6819 
 
6820 
  def __init__(self, success=None, ex=None,):
6821 
    self.success = success
6822 
    self.ex = ex
6823 
 
6824 
  def read(self, iprot):
6825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6827 
      return
6828 
    iprot.readStructBegin()
6829 
    while True:
6830 
      (fname, ftype, fid) = iprot.readFieldBegin()
6831 
      if ftype == TType.STOP:
6832 
        break
6833 
      if fid == 0:
6834 
        if ftype == TType.BOOL:
6835 
          self.success = iprot.readBool();
6836 
        else:
6837 
          iprot.skip(ftype)
6838 
      elif fid == 1:
6839 
        if ftype == TType.STRUCT:
6840 
          self.ex = TransactionServiceException()
6841 
          self.ex.read(iprot)
6842 
        else:
6843 
          iprot.skip(ftype)
6844 
      else:
6845 
        iprot.skip(ftype)
6846 
      iprot.readFieldEnd()
6847 
    iprot.readStructEnd()
6848 
 
6849 
  def write(self, oprot):
6850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6852 
      return
1398 varun.gupt 6853 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6854 
    if self.success is not None:
1382 varun.gupt 6855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6856 
      oprot.writeBool(self.success)
6857 
      oprot.writeFieldEnd()
3431 rajveer 6858 
    if self.ex is not None:
1382 varun.gupt 6859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6860 
      self.ex.write(oprot)
6861 
      oprot.writeFieldEnd()
6862 
    oprot.writeFieldStop()
6863 
    oprot.writeStructEnd()
6864 
 
3431 rajveer 6865 
  def validate(self):
6866 
    return
6867 
 
6868 
 
1382 varun.gupt 6869 
  def __repr__(self):
6870 
    L = ['%s=%r' % (key, value)
6871 
      for key, value in self.__dict__.iteritems()]
6872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6873 
 
6874 
  def __eq__(self, other):
6875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6876 
 
6877 
  def __ne__(self, other):
6878 
    return not (self == other)
6879 
 
483 rajveer 6880 
class getAllOrders_args:
94 ashish 6881 
  """
6882 
  Attributes:
483 rajveer 6883 
   - status
6884 
   - from_date
6885 
   - to_date
6886 
   - warehouse_id
94 ashish 6887 
  """
6888 
 
6889 
  thrift_spec = (
6890 
    None, # 0
483 rajveer 6891 
    (1, TType.I32, 'status', None, None, ), # 1
6892 
    (2, TType.I64, 'from_date', None, None, ), # 2
6893 
    (3, TType.I64, 'to_date', None, None, ), # 3
6894 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6895 
  )
6896 
 
483 rajveer 6897 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6898 
    self.status = status
6899 
    self.from_date = from_date
6900 
    self.to_date = to_date
6901 
    self.warehouse_id = warehouse_id
94 ashish 6902 
 
6903 
  def read(self, iprot):
6904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6906 
      return
6907 
    iprot.readStructBegin()
6908 
    while True:
6909 
      (fname, ftype, fid) = iprot.readFieldBegin()
6910 
      if ftype == TType.STOP:
6911 
        break
6912 
      if fid == 1:
483 rajveer 6913 
        if ftype == TType.I32:
6914 
          self.status = iprot.readI32();
94 ashish 6915 
        else:
6916 
          iprot.skip(ftype)
483 rajveer 6917 
      elif fid == 2:
6918 
        if ftype == TType.I64:
6919 
          self.from_date = iprot.readI64();
94 ashish 6920 
        else:
6921 
          iprot.skip(ftype)
483 rajveer 6922 
      elif fid == 3:
6923 
        if ftype == TType.I64:
6924 
          self.to_date = iprot.readI64();
94 ashish 6925 
        else:
6926 
          iprot.skip(ftype)
483 rajveer 6927 
      elif fid == 4:
94 ashish 6928 
        if ftype == TType.I64:
483 rajveer 6929 
          self.warehouse_id = iprot.readI64();
94 ashish 6930 
        else:
6931 
          iprot.skip(ftype)
6932 
      else:
6933 
        iprot.skip(ftype)
6934 
      iprot.readFieldEnd()
6935 
    iprot.readStructEnd()
6936 
 
6937 
  def write(self, oprot):
6938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6940 
      return
483 rajveer 6941 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6942 
    if self.status is not None:
483 rajveer 6943 
      oprot.writeFieldBegin('status', TType.I32, 1)
6944 
      oprot.writeI32(self.status)
94 ashish 6945 
      oprot.writeFieldEnd()
3431 rajveer 6946 
    if self.from_date is not None:
483 rajveer 6947 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6948 
      oprot.writeI64(self.from_date)
94 ashish 6949 
      oprot.writeFieldEnd()
3431 rajveer 6950 
    if self.to_date is not None:
483 rajveer 6951 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6952 
      oprot.writeI64(self.to_date)
94 ashish 6953 
      oprot.writeFieldEnd()
3431 rajveer 6954 
    if self.warehouse_id is not None:
483 rajveer 6955 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6956 
      oprot.writeI64(self.warehouse_id)
94 ashish 6957 
      oprot.writeFieldEnd()
6958 
    oprot.writeFieldStop()
6959 
    oprot.writeStructEnd()
6960 
 
3431 rajveer 6961 
  def validate(self):
6962 
    return
6963 
 
6964 
 
94 ashish 6965 
  def __repr__(self):
6966 
    L = ['%s=%r' % (key, value)
6967 
      for key, value in self.__dict__.iteritems()]
6968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6969 
 
6970 
  def __eq__(self, other):
6971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6972 
 
6973 
  def __ne__(self, other):
6974 
    return not (self == other)
6975 
 
483 rajveer 6976 
class getAllOrders_result:
94 ashish 6977 
  """
6978 
  Attributes:
6979 
   - success
6980 
   - ex
6981 
  """
6982 
 
6983 
  thrift_spec = (
483 rajveer 6984 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6985 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6986 
  )
6987 
 
6988 
  def __init__(self, success=None, ex=None,):
6989 
    self.success = success
6990 
    self.ex = ex
6991 
 
6992 
  def read(self, iprot):
6993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6995 
      return
6996 
    iprot.readStructBegin()
6997 
    while True:
6998 
      (fname, ftype, fid) = iprot.readFieldBegin()
6999 
      if ftype == TType.STOP:
7000 
        break
7001 
      if fid == 0:
483 rajveer 7002 
        if ftype == TType.LIST:
7003 
          self.success = []
685 chandransh 7004 
          (_etype31, _size28) = iprot.readListBegin()
7005 
          for _i32 in xrange(_size28):
7006 
            _elem33 = Order()
7007 
            _elem33.read(iprot)
7008 
            self.success.append(_elem33)
483 rajveer 7009 
          iprot.readListEnd()
94 ashish 7010 
        else:
7011 
          iprot.skip(ftype)
7012 
      elif fid == 1:
7013 
        if ftype == TType.STRUCT:
7014 
          self.ex = TransactionServiceException()
7015 
          self.ex.read(iprot)
7016 
        else:
7017 
          iprot.skip(ftype)
7018 
      else:
7019 
        iprot.skip(ftype)
7020 
      iprot.readFieldEnd()
7021 
    iprot.readStructEnd()
7022 
 
7023 
  def write(self, oprot):
7024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7026 
      return
483 rajveer 7027 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7028 
    if self.success is not None:
483 rajveer 7029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 7031 
      for iter34 in self.success:
7032 
        iter34.write(oprot)
483 rajveer 7033 
      oprot.writeListEnd()
94 ashish 7034 
      oprot.writeFieldEnd()
3431 rajveer 7035 
    if self.ex is not None:
94 ashish 7036 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7037 
      self.ex.write(oprot)
7038 
      oprot.writeFieldEnd()
7039 
    oprot.writeFieldStop()
7040 
    oprot.writeStructEnd()
7041 
 
3431 rajveer 7042 
  def validate(self):
7043 
    return
7044 
 
7045 
 
94 ashish 7046 
  def __repr__(self):
7047 
    L = ['%s=%r' % (key, value)
7048 
      for key, value in self.__dict__.iteritems()]
7049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7050 
 
7051 
  def __eq__(self, other):
7052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7053 
 
7054 
  def __ne__(self, other):
7055 
    return not (self == other)
7056 
 
4133 chandransh 7057 
class getOrdersInBatch_args:
7058 
  """
7059 
  Attributes:
7060 
   - statuses
7061 
   - offset
7062 
   - limit
7063 
   - warehouse_id
7064 
  """
7065 
 
7066 
  thrift_spec = (
7067 
    None, # 0
7068 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7069 
    (2, TType.I64, 'offset', None, None, ), # 2
7070 
    (3, TType.I64, 'limit', None, None, ), # 3
7071 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7072 
  )
7073 
 
7074 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7075 
    self.statuses = statuses
7076 
    self.offset = offset
7077 
    self.limit = limit
7078 
    self.warehouse_id = warehouse_id
7079 
 
7080 
  def read(self, iprot):
7081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7083 
      return
7084 
    iprot.readStructBegin()
7085 
    while True:
7086 
      (fname, ftype, fid) = iprot.readFieldBegin()
7087 
      if ftype == TType.STOP:
7088 
        break
7089 
      if fid == 1:
7090 
        if ftype == TType.LIST:
7091 
          self.statuses = []
7092 
          (_etype38, _size35) = iprot.readListBegin()
7093 
          for _i39 in xrange(_size35):
7094 
            _elem40 = iprot.readI32();
7095 
            self.statuses.append(_elem40)
7096 
          iprot.readListEnd()
7097 
        else:
7098 
          iprot.skip(ftype)
7099 
      elif fid == 2:
7100 
        if ftype == TType.I64:
7101 
          self.offset = iprot.readI64();
7102 
        else:
7103 
          iprot.skip(ftype)
7104 
      elif fid == 3:
7105 
        if ftype == TType.I64:
7106 
          self.limit = iprot.readI64();
7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      elif fid == 4:
7110 
        if ftype == TType.I64:
7111 
          self.warehouse_id = iprot.readI64();
7112 
        else:
7113 
          iprot.skip(ftype)
7114 
      else:
7115 
        iprot.skip(ftype)
7116 
      iprot.readFieldEnd()
7117 
    iprot.readStructEnd()
7118 
 
7119 
  def write(self, oprot):
7120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7122 
      return
7123 
    oprot.writeStructBegin('getOrdersInBatch_args')
7124 
    if self.statuses is not None:
7125 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7126 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7127 
      for iter41 in self.statuses:
7128 
        oprot.writeI32(iter41)
7129 
      oprot.writeListEnd()
7130 
      oprot.writeFieldEnd()
7131 
    if self.offset is not None:
7132 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7133 
      oprot.writeI64(self.offset)
7134 
      oprot.writeFieldEnd()
7135 
    if self.limit is not None:
7136 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7137 
      oprot.writeI64(self.limit)
7138 
      oprot.writeFieldEnd()
7139 
    if self.warehouse_id is not None:
7140 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7141 
      oprot.writeI64(self.warehouse_id)
7142 
      oprot.writeFieldEnd()
7143 
    oprot.writeFieldStop()
7144 
    oprot.writeStructEnd()
7145 
 
7146 
  def validate(self):
7147 
    return
7148 
 
7149 
 
7150 
  def __repr__(self):
7151 
    L = ['%s=%r' % (key, value)
7152 
      for key, value in self.__dict__.iteritems()]
7153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7154 
 
7155 
  def __eq__(self, other):
7156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7157 
 
7158 
  def __ne__(self, other):
7159 
    return not (self == other)
7160 
 
7161 
class getOrdersInBatch_result:
7162 
  """
7163 
  Attributes:
7164 
   - success
7165 
   - ex
7166 
  """
7167 
 
7168 
  thrift_spec = (
7169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7171 
  )
7172 
 
7173 
  def __init__(self, success=None, ex=None,):
7174 
    self.success = success
7175 
    self.ex = ex
7176 
 
7177 
  def read(self, iprot):
7178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7180 
      return
7181 
    iprot.readStructBegin()
7182 
    while True:
7183 
      (fname, ftype, fid) = iprot.readFieldBegin()
7184 
      if ftype == TType.STOP:
7185 
        break
7186 
      if fid == 0:
7187 
        if ftype == TType.LIST:
7188 
          self.success = []
7189 
          (_etype45, _size42) = iprot.readListBegin()
7190 
          for _i46 in xrange(_size42):
7191 
            _elem47 = Order()
7192 
            _elem47.read(iprot)
7193 
            self.success.append(_elem47)
7194 
          iprot.readListEnd()
7195 
        else:
7196 
          iprot.skip(ftype)
7197 
      elif fid == 1:
7198 
        if ftype == TType.STRUCT:
7199 
          self.ex = TransactionServiceException()
7200 
          self.ex.read(iprot)
7201 
        else:
7202 
          iprot.skip(ftype)
7203 
      else:
7204 
        iprot.skip(ftype)
7205 
      iprot.readFieldEnd()
7206 
    iprot.readStructEnd()
7207 
 
7208 
  def write(self, oprot):
7209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7211 
      return
7212 
    oprot.writeStructBegin('getOrdersInBatch_result')
7213 
    if self.success is not None:
7214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 
      for iter48 in self.success:
7217 
        iter48.write(oprot)
7218 
      oprot.writeListEnd()
7219 
      oprot.writeFieldEnd()
7220 
    if self.ex is not None:
7221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7222 
      self.ex.write(oprot)
7223 
      oprot.writeFieldEnd()
7224 
    oprot.writeFieldStop()
7225 
    oprot.writeStructEnd()
7226 
 
7227 
  def validate(self):
7228 
    return
7229 
 
7230 
 
7231 
  def __repr__(self):
7232 
    L = ['%s=%r' % (key, value)
7233 
      for key, value in self.__dict__.iteritems()]
7234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7235 
 
7236 
  def __eq__(self, other):
7237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7238 
 
7239 
  def __ne__(self, other):
7240 
    return not (self == other)
7241 
 
7242 
class getOrderCount_args:
7243 
  """
7244 
  Attributes:
7245 
   - statuses
7246 
   - warehouseId
7247 
  """
7248 
 
7249 
  thrift_spec = (
7250 
    None, # 0
7251 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7252 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7253 
  )
7254 
 
7255 
  def __init__(self, statuses=None, warehouseId=None,):
7256 
    self.statuses = statuses
7257 
    self.warehouseId = warehouseId
7258 
 
7259 
  def read(self, iprot):
7260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7262 
      return
7263 
    iprot.readStructBegin()
7264 
    while True:
7265 
      (fname, ftype, fid) = iprot.readFieldBegin()
7266 
      if ftype == TType.STOP:
7267 
        break
7268 
      if fid == 1:
7269 
        if ftype == TType.LIST:
7270 
          self.statuses = []
7271 
          (_etype52, _size49) = iprot.readListBegin()
7272 
          for _i53 in xrange(_size49):
7273 
            _elem54 = iprot.readI32();
7274 
            self.statuses.append(_elem54)
7275 
          iprot.readListEnd()
7276 
        else:
7277 
          iprot.skip(ftype)
7278 
      elif fid == 2:
7279 
        if ftype == TType.I64:
7280 
          self.warehouseId = iprot.readI64();
7281 
        else:
7282 
          iprot.skip(ftype)
7283 
      else:
7284 
        iprot.skip(ftype)
7285 
      iprot.readFieldEnd()
7286 
    iprot.readStructEnd()
7287 
 
7288 
  def write(self, oprot):
7289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7291 
      return
7292 
    oprot.writeStructBegin('getOrderCount_args')
7293 
    if self.statuses is not None:
7294 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7295 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7296 
      for iter55 in self.statuses:
7297 
        oprot.writeI32(iter55)
7298 
      oprot.writeListEnd()
7299 
      oprot.writeFieldEnd()
7300 
    if self.warehouseId is not None:
7301 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7302 
      oprot.writeI64(self.warehouseId)
7303 
      oprot.writeFieldEnd()
7304 
    oprot.writeFieldStop()
7305 
    oprot.writeStructEnd()
7306 
 
7307 
  def validate(self):
7308 
    return
7309 
 
7310 
 
7311 
  def __repr__(self):
7312 
    L = ['%s=%r' % (key, value)
7313 
      for key, value in self.__dict__.iteritems()]
7314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7315 
 
7316 
  def __eq__(self, other):
7317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7318 
 
7319 
  def __ne__(self, other):
7320 
    return not (self == other)
7321 
 
7322 
class getOrderCount_result:
7323 
  """
7324 
  Attributes:
7325 
   - success
7326 
   - ex
7327 
  """
7328 
 
7329 
  thrift_spec = (
7330 
    (0, TType.I32, 'success', None, None, ), # 0
7331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7332 
  )
7333 
 
7334 
  def __init__(self, success=None, ex=None,):
7335 
    self.success = success
7336 
    self.ex = ex
7337 
 
7338 
  def read(self, iprot):
7339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7341 
      return
7342 
    iprot.readStructBegin()
7343 
    while True:
7344 
      (fname, ftype, fid) = iprot.readFieldBegin()
7345 
      if ftype == TType.STOP:
7346 
        break
7347 
      if fid == 0:
7348 
        if ftype == TType.I32:
7349 
          self.success = iprot.readI32();
7350 
        else:
7351 
          iprot.skip(ftype)
7352 
      elif fid == 1:
7353 
        if ftype == TType.STRUCT:
7354 
          self.ex = TransactionServiceException()
7355 
          self.ex.read(iprot)
7356 
        else:
7357 
          iprot.skip(ftype)
7358 
      else:
7359 
        iprot.skip(ftype)
7360 
      iprot.readFieldEnd()
7361 
    iprot.readStructEnd()
7362 
 
7363 
  def write(self, oprot):
7364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7366 
      return
7367 
    oprot.writeStructBegin('getOrderCount_result')
7368 
    if self.success is not None:
7369 
      oprot.writeFieldBegin('success', TType.I32, 0)
7370 
      oprot.writeI32(self.success)
7371 
      oprot.writeFieldEnd()
7372 
    if self.ex is not None:
7373 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7374 
      self.ex.write(oprot)
7375 
      oprot.writeFieldEnd()
7376 
    oprot.writeFieldStop()
7377 
    oprot.writeStructEnd()
7378 
 
7379 
  def validate(self):
7380 
    return
7381 
 
7382 
 
7383 
  def __repr__(self):
7384 
    L = ['%s=%r' % (key, value)
7385 
      for key, value in self.__dict__.iteritems()]
7386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7387 
 
7388 
  def __eq__(self, other):
7389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7390 
 
7391 
  def __ne__(self, other):
7392 
    return not (self == other)
7393 
 
999 varun.gupt 7394 
class getOrdersByBillingDate_args:
7395 
  """
7396 
  Attributes:
7397 
   - status
7398 
   - start_billing_date
7399 
   - end_billing_date
7400 
   - warehouse_id
7401 
  """
7402 
 
7403 
  thrift_spec = (
7404 
    None, # 0
7405 
    (1, TType.I32, 'status', None, None, ), # 1
7406 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7407 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7408 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7409 
  )
7410 
 
7411 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7412 
    self.status = status
7413 
    self.start_billing_date = start_billing_date
7414 
    self.end_billing_date = end_billing_date
7415 
    self.warehouse_id = warehouse_id
7416 
 
7417 
  def read(self, iprot):
7418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7420 
      return
7421 
    iprot.readStructBegin()
7422 
    while True:
7423 
      (fname, ftype, fid) = iprot.readFieldBegin()
7424 
      if ftype == TType.STOP:
7425 
        break
7426 
      if fid == 1:
7427 
        if ftype == TType.I32:
7428 
          self.status = iprot.readI32();
7429 
        else:
7430 
          iprot.skip(ftype)
7431 
      elif fid == 2:
7432 
        if ftype == TType.I64:
7433 
          self.start_billing_date = iprot.readI64();
7434 
        else:
7435 
          iprot.skip(ftype)
7436 
      elif fid == 3:
7437 
        if ftype == TType.I64:
7438 
          self.end_billing_date = iprot.readI64();
7439 
        else:
7440 
          iprot.skip(ftype)
7441 
      elif fid == 4:
7442 
        if ftype == TType.I64:
7443 
          self.warehouse_id = iprot.readI64();
7444 
        else:
7445 
          iprot.skip(ftype)
7446 
      else:
7447 
        iprot.skip(ftype)
7448 
      iprot.readFieldEnd()
7449 
    iprot.readStructEnd()
7450 
 
7451 
  def write(self, oprot):
7452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7454 
      return
7455 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7456 
    if self.status is not None:
999 varun.gupt 7457 
      oprot.writeFieldBegin('status', TType.I32, 1)
7458 
      oprot.writeI32(self.status)
7459 
      oprot.writeFieldEnd()
3431 rajveer 7460 
    if self.start_billing_date is not None:
999 varun.gupt 7461 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7462 
      oprot.writeI64(self.start_billing_date)
7463 
      oprot.writeFieldEnd()
3431 rajveer 7464 
    if self.end_billing_date is not None:
999 varun.gupt 7465 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7466 
      oprot.writeI64(self.end_billing_date)
7467 
      oprot.writeFieldEnd()
3431 rajveer 7468 
    if self.warehouse_id is not None:
999 varun.gupt 7469 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7470 
      oprot.writeI64(self.warehouse_id)
7471 
      oprot.writeFieldEnd()
7472 
    oprot.writeFieldStop()
7473 
    oprot.writeStructEnd()
7474 
 
3431 rajveer 7475 
  def validate(self):
7476 
    return
7477 
 
7478 
 
999 varun.gupt 7479 
  def __repr__(self):
7480 
    L = ['%s=%r' % (key, value)
7481 
      for key, value in self.__dict__.iteritems()]
7482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7483 
 
7484 
  def __eq__(self, other):
7485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7486 
 
7487 
  def __ne__(self, other):
7488 
    return not (self == other)
7489 
 
7490 
class getOrdersByBillingDate_result:
7491 
  """
7492 
  Attributes:
7493 
   - success
7494 
   - ex
7495 
  """
7496 
 
7497 
  thrift_spec = (
7498 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7500 
  )
7501 
 
7502 
  def __init__(self, success=None, ex=None,):
7503 
    self.success = success
7504 
    self.ex = ex
7505 
 
7506 
  def read(self, iprot):
7507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7509 
      return
7510 
    iprot.readStructBegin()
7511 
    while True:
7512 
      (fname, ftype, fid) = iprot.readFieldBegin()
7513 
      if ftype == TType.STOP:
7514 
        break
7515 
      if fid == 0:
7516 
        if ftype == TType.LIST:
7517 
          self.success = []
4133 chandransh 7518 
          (_etype59, _size56) = iprot.readListBegin()
7519 
          for _i60 in xrange(_size56):
7520 
            _elem61 = Order()
7521 
            _elem61.read(iprot)
7522 
            self.success.append(_elem61)
999 varun.gupt 7523 
          iprot.readListEnd()
7524 
        else:
7525 
          iprot.skip(ftype)
7526 
      elif fid == 1:
7527 
        if ftype == TType.STRUCT:
7528 
          self.ex = TransactionServiceException()
7529 
          self.ex.read(iprot)
7530 
        else:
7531 
          iprot.skip(ftype)
7532 
      else:
7533 
        iprot.skip(ftype)
7534 
      iprot.readFieldEnd()
7535 
    iprot.readStructEnd()
7536 
 
7537 
  def write(self, oprot):
7538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7540 
      return
7541 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7542 
    if self.success is not None:
999 varun.gupt 7543 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7544 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7545 
      for iter62 in self.success:
7546 
        iter62.write(oprot)
999 varun.gupt 7547 
      oprot.writeListEnd()
7548 
      oprot.writeFieldEnd()
3431 rajveer 7549 
    if self.ex is not None:
999 varun.gupt 7550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7551 
      self.ex.write(oprot)
7552 
      oprot.writeFieldEnd()
7553 
    oprot.writeFieldStop()
7554 
    oprot.writeStructEnd()
7555 
 
3431 rajveer 7556 
  def validate(self):
7557 
    return
7558 
 
7559 
 
999 varun.gupt 7560 
  def __repr__(self):
7561 
    L = ['%s=%r' % (key, value)
7562 
      for key, value in self.__dict__.iteritems()]
7563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7564 
 
7565 
  def __eq__(self, other):
7566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7567 
 
7568 
  def __ne__(self, other):
7569 
    return not (self == other)
7570 
 
3427 chandransh 7571 
class getOrdersByShippingDate_args:
7572 
  """
7573 
  Attributes:
7574 
   - fromShippingDate
7575 
   - toShippingDate
7576 
   - providerId
7577 
   - warehouseId
3451 chandransh 7578 
   - cod
3427 chandransh 7579 
  """
7580 
 
7581 
  thrift_spec = (
7582 
    None, # 0
7583 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7584 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7585 
    (3, TType.I64, 'providerId', None, None, ), # 3
7586 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7587 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7588 
  )
7589 
 
3451 chandransh 7590 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7591 
    self.fromShippingDate = fromShippingDate
7592 
    self.toShippingDate = toShippingDate
7593 
    self.providerId = providerId
7594 
    self.warehouseId = warehouseId
3451 chandransh 7595 
    self.cod = cod
3427 chandransh 7596 
 
7597 
  def read(self, iprot):
7598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7600 
      return
7601 
    iprot.readStructBegin()
7602 
    while True:
7603 
      (fname, ftype, fid) = iprot.readFieldBegin()
7604 
      if ftype == TType.STOP:
7605 
        break
7606 
      if fid == 1:
7607 
        if ftype == TType.I64:
7608 
          self.fromShippingDate = iprot.readI64();
7609 
        else:
7610 
          iprot.skip(ftype)
7611 
      elif fid == 2:
7612 
        if ftype == TType.I64:
7613 
          self.toShippingDate = iprot.readI64();
7614 
        else:
7615 
          iprot.skip(ftype)
7616 
      elif fid == 3:
7617 
        if ftype == TType.I64:
7618 
          self.providerId = iprot.readI64();
7619 
        else:
7620 
          iprot.skip(ftype)
7621 
      elif fid == 4:
7622 
        if ftype == TType.I64:
7623 
          self.warehouseId = iprot.readI64();
7624 
        else:
7625 
          iprot.skip(ftype)
3451 chandransh 7626 
      elif fid == 5:
7627 
        if ftype == TType.BOOL:
7628 
          self.cod = iprot.readBool();
7629 
        else:
7630 
          iprot.skip(ftype)
3427 chandransh 7631 
      else:
7632 
        iprot.skip(ftype)
7633 
      iprot.readFieldEnd()
7634 
    iprot.readStructEnd()
7635 
 
7636 
  def write(self, oprot):
7637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7639 
      return
7640 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7641 
    if self.fromShippingDate is not None:
3427 chandransh 7642 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7643 
      oprot.writeI64(self.fromShippingDate)
7644 
      oprot.writeFieldEnd()
3431 rajveer 7645 
    if self.toShippingDate is not None:
3427 chandransh 7646 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7647 
      oprot.writeI64(self.toShippingDate)
7648 
      oprot.writeFieldEnd()
3431 rajveer 7649 
    if self.providerId is not None:
3427 chandransh 7650 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7651 
      oprot.writeI64(self.providerId)
7652 
      oprot.writeFieldEnd()
3431 rajveer 7653 
    if self.warehouseId is not None:
3427 chandransh 7654 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7655 
      oprot.writeI64(self.warehouseId)
7656 
      oprot.writeFieldEnd()
3451 chandransh 7657 
    if self.cod is not None:
7658 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7659 
      oprot.writeBool(self.cod)
7660 
      oprot.writeFieldEnd()
3427 chandransh 7661 
    oprot.writeFieldStop()
7662 
    oprot.writeStructEnd()
7663 
 
3431 rajveer 7664 
  def validate(self):
7665 
    return
7666 
 
7667 
 
3427 chandransh 7668 
  def __repr__(self):
7669 
    L = ['%s=%r' % (key, value)
7670 
      for key, value in self.__dict__.iteritems()]
7671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7672 
 
7673 
  def __eq__(self, other):
7674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7675 
 
7676 
  def __ne__(self, other):
7677 
    return not (self == other)
7678 
 
7679 
class getOrdersByShippingDate_result:
7680 
  """
7681 
  Attributes:
7682 
   - success
7683 
   - ex
7684 
  """
7685 
 
7686 
  thrift_spec = (
7687 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7689 
  )
7690 
 
7691 
  def __init__(self, success=None, ex=None,):
7692 
    self.success = success
7693 
    self.ex = ex
7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 0:
7705 
        if ftype == TType.LIST:
7706 
          self.success = []
4133 chandransh 7707 
          (_etype66, _size63) = iprot.readListBegin()
7708 
          for _i67 in xrange(_size63):
7709 
            _elem68 = Order()
7710 
            _elem68.read(iprot)
7711 
            self.success.append(_elem68)
3427 chandransh 7712 
          iprot.readListEnd()
7713 
        else:
7714 
          iprot.skip(ftype)
7715 
      elif fid == 1:
7716 
        if ftype == TType.STRUCT:
7717 
          self.ex = TransactionServiceException()
7718 
          self.ex.read(iprot)
7719 
        else:
7720 
          iprot.skip(ftype)
7721 
      else:
7722 
        iprot.skip(ftype)
7723 
      iprot.readFieldEnd()
7724 
    iprot.readStructEnd()
7725 
 
7726 
  def write(self, oprot):
7727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7729 
      return
7730 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7731 
    if self.success is not None:
3427 chandransh 7732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7734 
      for iter69 in self.success:
7735 
        iter69.write(oprot)
3427 chandransh 7736 
      oprot.writeListEnd()
7737 
      oprot.writeFieldEnd()
3431 rajveer 7738 
    if self.ex is not None:
3427 chandransh 7739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7740 
      self.ex.write(oprot)
7741 
      oprot.writeFieldEnd()
7742 
    oprot.writeFieldStop()
7743 
    oprot.writeStructEnd()
7744 
 
3431 rajveer 7745 
  def validate(self):
7746 
    return
7747 
 
7748 
 
3427 chandransh 7749 
  def __repr__(self):
7750 
    L = ['%s=%r' % (key, value)
7751 
      for key, value in self.__dict__.iteritems()]
7752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7753 
 
7754 
  def __eq__(self, other):
7755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7756 
 
7757 
  def __ne__(self, other):
7758 
    return not (self == other)
7759 
 
1382 varun.gupt 7760 
class getReturnableOrdersForCustomer_args:
7761 
  """
7762 
  Attributes:
7763 
   - customer_id
7764 
   - limit
7765 
  """
7766 
 
7767 
  thrift_spec = (
7768 
    None, # 0
7769 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7770 
    (2, TType.I64, 'limit', None, None, ), # 2
7771 
  )
7772 
 
7773 
  def __init__(self, customer_id=None, limit=None,):
7774 
    self.customer_id = customer_id
7775 
    self.limit = limit
7776 
 
7777 
  def read(self, iprot):
7778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7780 
      return
7781 
    iprot.readStructBegin()
7782 
    while True:
7783 
      (fname, ftype, fid) = iprot.readFieldBegin()
7784 
      if ftype == TType.STOP:
7785 
        break
7786 
      if fid == 1:
7787 
        if ftype == TType.I64:
7788 
          self.customer_id = iprot.readI64();
7789 
        else:
7790 
          iprot.skip(ftype)
7791 
      elif fid == 2:
7792 
        if ftype == TType.I64:
7793 
          self.limit = iprot.readI64();
7794 
        else:
7795 
          iprot.skip(ftype)
7796 
      else:
7797 
        iprot.skip(ftype)
7798 
      iprot.readFieldEnd()
7799 
    iprot.readStructEnd()
7800 
 
7801 
  def write(self, oprot):
7802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7804 
      return
7805 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7806 
    if self.customer_id is not None:
1382 varun.gupt 7807 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7808 
      oprot.writeI64(self.customer_id)
7809 
      oprot.writeFieldEnd()
3431 rajveer 7810 
    if self.limit is not None:
1382 varun.gupt 7811 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7812 
      oprot.writeI64(self.limit)
7813 
      oprot.writeFieldEnd()
7814 
    oprot.writeFieldStop()
7815 
    oprot.writeStructEnd()
7816 
 
3431 rajveer 7817 
  def validate(self):
7818 
    return
7819 
 
7820 
 
1382 varun.gupt 7821 
  def __repr__(self):
7822 
    L = ['%s=%r' % (key, value)
7823 
      for key, value in self.__dict__.iteritems()]
7824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7825 
 
7826 
  def __eq__(self, other):
7827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7828 
 
7829 
  def __ne__(self, other):
7830 
    return not (self == other)
7831 
 
7832 
class getReturnableOrdersForCustomer_result:
7833 
  """
7834 
  Attributes:
7835 
   - success
7836 
   - ex
7837 
  """
7838 
 
7839 
  thrift_spec = (
7840 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7841 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7842 
  )
7843 
 
7844 
  def __init__(self, success=None, ex=None,):
7845 
    self.success = success
7846 
    self.ex = ex
7847 
 
7848 
  def read(self, iprot):
7849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7851 
      return
7852 
    iprot.readStructBegin()
7853 
    while True:
7854 
      (fname, ftype, fid) = iprot.readFieldBegin()
7855 
      if ftype == TType.STOP:
7856 
        break
7857 
      if fid == 0:
7858 
        if ftype == TType.LIST:
7859 
          self.success = []
4133 chandransh 7860 
          (_etype73, _size70) = iprot.readListBegin()
7861 
          for _i74 in xrange(_size70):
7862 
            _elem75 = iprot.readI64();
7863 
            self.success.append(_elem75)
1382 varun.gupt 7864 
          iprot.readListEnd()
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      elif fid == 1:
7868 
        if ftype == TType.STRUCT:
7869 
          self.ex = TransactionServiceException()
7870 
          self.ex.read(iprot)
7871 
        else:
7872 
          iprot.skip(ftype)
7873 
      else:
7874 
        iprot.skip(ftype)
7875 
      iprot.readFieldEnd()
7876 
    iprot.readStructEnd()
7877 
 
7878 
  def write(self, oprot):
7879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7881 
      return
7882 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7883 
    if self.success is not None:
1382 varun.gupt 7884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7885 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7886 
      for iter76 in self.success:
7887 
        oprot.writeI64(iter76)
1382 varun.gupt 7888 
      oprot.writeListEnd()
7889 
      oprot.writeFieldEnd()
3431 rajveer 7890 
    if self.ex is not None:
1382 varun.gupt 7891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7892 
      self.ex.write(oprot)
7893 
      oprot.writeFieldEnd()
7894 
    oprot.writeFieldStop()
7895 
    oprot.writeStructEnd()
7896 
 
3431 rajveer 7897 
  def validate(self):
7898 
    return
7899 
 
7900 
 
1382 varun.gupt 7901 
  def __repr__(self):
7902 
    L = ['%s=%r' % (key, value)
7903 
      for key, value in self.__dict__.iteritems()]
7904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7905 
 
7906 
  def __eq__(self, other):
7907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7908 
 
7909 
  def __ne__(self, other):
7910 
    return not (self == other)
7911 
 
7912 
class getCancellableOrdersForCustomer_args:
7913 
  """
7914 
  Attributes:
7915 
   - customer_id
7916 
   - limit
7917 
  """
7918 
 
7919 
  thrift_spec = (
7920 
    None, # 0
7921 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7922 
    (2, TType.I64, 'limit', None, None, ), # 2
7923 
  )
7924 
 
7925 
  def __init__(self, customer_id=None, limit=None,):
7926 
    self.customer_id = customer_id
7927 
    self.limit = limit
7928 
 
7929 
  def read(self, iprot):
7930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7932 
      return
7933 
    iprot.readStructBegin()
7934 
    while True:
7935 
      (fname, ftype, fid) = iprot.readFieldBegin()
7936 
      if ftype == TType.STOP:
7937 
        break
7938 
      if fid == 1:
7939 
        if ftype == TType.I64:
7940 
          self.customer_id = iprot.readI64();
7941 
        else:
7942 
          iprot.skip(ftype)
7943 
      elif fid == 2:
7944 
        if ftype == TType.I64:
7945 
          self.limit = iprot.readI64();
7946 
        else:
7947 
          iprot.skip(ftype)
7948 
      else:
7949 
        iprot.skip(ftype)
7950 
      iprot.readFieldEnd()
7951 
    iprot.readStructEnd()
7952 
 
7953 
  def write(self, oprot):
7954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7956 
      return
7957 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7958 
    if self.customer_id is not None:
1382 varun.gupt 7959 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7960 
      oprot.writeI64(self.customer_id)
7961 
      oprot.writeFieldEnd()
3431 rajveer 7962 
    if self.limit is not None:
1382 varun.gupt 7963 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7964 
      oprot.writeI64(self.limit)
7965 
      oprot.writeFieldEnd()
7966 
    oprot.writeFieldStop()
7967 
    oprot.writeStructEnd()
7968 
 
3431 rajveer 7969 
  def validate(self):
7970 
    return
7971 
 
7972 
 
1382 varun.gupt 7973 
  def __repr__(self):
7974 
    L = ['%s=%r' % (key, value)
7975 
      for key, value in self.__dict__.iteritems()]
7976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7977 
 
7978 
  def __eq__(self, other):
7979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7980 
 
7981 
  def __ne__(self, other):
7982 
    return not (self == other)
7983 
 
7984 
class getCancellableOrdersForCustomer_result:
7985 
  """
7986 
  Attributes:
7987 
   - success
7988 
   - ex
7989 
  """
7990 
 
7991 
  thrift_spec = (
7992 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7994 
  )
7995 
 
7996 
  def __init__(self, success=None, ex=None,):
7997 
    self.success = success
7998 
    self.ex = ex
7999 
 
8000 
  def read(self, iprot):
8001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8003 
      return
8004 
    iprot.readStructBegin()
8005 
    while True:
8006 
      (fname, ftype, fid) = iprot.readFieldBegin()
8007 
      if ftype == TType.STOP:
8008 
        break
8009 
      if fid == 0:
8010 
        if ftype == TType.LIST:
8011 
          self.success = []
4133 chandransh 8012 
          (_etype80, _size77) = iprot.readListBegin()
8013 
          for _i81 in xrange(_size77):
8014 
            _elem82 = iprot.readI64();
8015 
            self.success.append(_elem82)
1382 varun.gupt 8016 
          iprot.readListEnd()
8017 
        else:
8018 
          iprot.skip(ftype)
8019 
      elif fid == 1:
8020 
        if ftype == TType.STRUCT:
8021 
          self.ex = TransactionServiceException()
8022 
          self.ex.read(iprot)
8023 
        else:
8024 
          iprot.skip(ftype)
8025 
      else:
8026 
        iprot.skip(ftype)
8027 
      iprot.readFieldEnd()
8028 
    iprot.readStructEnd()
8029 
 
8030 
  def write(self, oprot):
8031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8033 
      return
8034 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8035 
    if self.success is not None:
1382 varun.gupt 8036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8037 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 8038 
      for iter83 in self.success:
8039 
        oprot.writeI64(iter83)
1382 varun.gupt 8040 
      oprot.writeListEnd()
8041 
      oprot.writeFieldEnd()
3431 rajveer 8042 
    if self.ex is not None:
1382 varun.gupt 8043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8044 
      self.ex.write(oprot)
8045 
      oprot.writeFieldEnd()
8046 
    oprot.writeFieldStop()
8047 
    oprot.writeStructEnd()
8048 
 
3431 rajveer 8049 
  def validate(self):
8050 
    return
8051 
 
8052 
 
1382 varun.gupt 8053 
  def __repr__(self):
8054 
    L = ['%s=%r' % (key, value)
8055 
      for key, value in self.__dict__.iteritems()]
8056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8057 
 
8058 
  def __eq__(self, other):
8059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8060 
 
8061 
  def __ne__(self, other):
8062 
    return not (self == other)
8063 
 
483 rajveer 8064 
class changeOrderStatus_args:
94 ashish 8065 
  """
8066 
  Attributes:
483 rajveer 8067 
   - orderId
8068 
   - status
8069 
   - description
94 ashish 8070 
  """
8071 
 
8072 
  thrift_spec = (
8073 
    None, # 0
483 rajveer 8074 
    (1, TType.I64, 'orderId', None, None, ), # 1
8075 
    (2, TType.I32, 'status', None, None, ), # 2
8076 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8077 
  )
8078 
 
483 rajveer 8079 
  def __init__(self, orderId=None, status=None, description=None,):
8080 
    self.orderId = orderId
8081 
    self.status = status
8082 
    self.description = description
94 ashish 8083 
 
8084 
  def read(self, iprot):
8085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8087 
      return
8088 
    iprot.readStructBegin()
8089 
    while True:
8090 
      (fname, ftype, fid) = iprot.readFieldBegin()
8091 
      if ftype == TType.STOP:
8092 
        break
8093 
      if fid == 1:
8094 
        if ftype == TType.I64:
483 rajveer 8095 
          self.orderId = iprot.readI64();
94 ashish 8096 
        else:
8097 
          iprot.skip(ftype)
8098 
      elif fid == 2:
483 rajveer 8099 
        if ftype == TType.I32:
8100 
          self.status = iprot.readI32();
94 ashish 8101 
        else:
8102 
          iprot.skip(ftype)
483 rajveer 8103 
      elif fid == 3:
8104 
        if ftype == TType.STRING:
8105 
          self.description = iprot.readString();
8106 
        else:
8107 
          iprot.skip(ftype)
94 ashish 8108 
      else:
8109 
        iprot.skip(ftype)
8110 
      iprot.readFieldEnd()
8111 
    iprot.readStructEnd()
8112 
 
8113 
  def write(self, oprot):
8114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8116 
      return
483 rajveer 8117 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8118 
    if self.orderId is not None:
483 rajveer 8119 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8120 
      oprot.writeI64(self.orderId)
94 ashish 8121 
      oprot.writeFieldEnd()
3431 rajveer 8122 
    if self.status is not None:
483 rajveer 8123 
      oprot.writeFieldBegin('status', TType.I32, 2)
8124 
      oprot.writeI32(self.status)
94 ashish 8125 
      oprot.writeFieldEnd()
3431 rajveer 8126 
    if self.description is not None:
483 rajveer 8127 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8128 
      oprot.writeString(self.description)
8129 
      oprot.writeFieldEnd()
94 ashish 8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
3431 rajveer 8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
94 ashish 8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
483 rajveer 8148 
class changeOrderStatus_result:
94 ashish 8149 
  """
8150 
  Attributes:
8151 
   - success
8152 
   - ex
8153 
  """
8154 
 
8155 
  thrift_spec = (
8156 
    (0, TType.BOOL, 'success', None, None, ), # 0
8157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8158 
  )
8159 
 
8160 
  def __init__(self, success=None, ex=None,):
8161 
    self.success = success
8162 
    self.ex = ex
8163 
 
8164 
  def read(self, iprot):
8165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8167 
      return
8168 
    iprot.readStructBegin()
8169 
    while True:
8170 
      (fname, ftype, fid) = iprot.readFieldBegin()
8171 
      if ftype == TType.STOP:
8172 
        break
8173 
      if fid == 0:
8174 
        if ftype == TType.BOOL:
8175 
          self.success = iprot.readBool();
8176 
        else:
8177 
          iprot.skip(ftype)
8178 
      elif fid == 1:
8179 
        if ftype == TType.STRUCT:
8180 
          self.ex = TransactionServiceException()
8181 
          self.ex.read(iprot)
8182 
        else:
8183 
          iprot.skip(ftype)
8184 
      else:
8185 
        iprot.skip(ftype)
8186 
      iprot.readFieldEnd()
8187 
    iprot.readStructEnd()
8188 
 
8189 
  def write(self, oprot):
8190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8192 
      return
483 rajveer 8193 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8194 
    if self.success is not None:
94 ashish 8195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8196 
      oprot.writeBool(self.success)
8197 
      oprot.writeFieldEnd()
3431 rajveer 8198 
    if self.ex is not None:
94 ashish 8199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8200 
      self.ex.write(oprot)
8201 
      oprot.writeFieldEnd()
8202 
    oprot.writeFieldStop()
8203 
    oprot.writeStructEnd()
8204 
 
3431 rajveer 8205 
  def validate(self):
8206 
    return
8207 
 
8208 
 
94 ashish 8209 
  def __repr__(self):
8210 
    L = ['%s=%r' % (key, value)
8211 
      for key, value in self.__dict__.iteritems()]
8212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8213 
 
8214 
  def __eq__(self, other):
8215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8216 
 
8217 
  def __ne__(self, other):
8218 
    return not (self == other)
8219 
 
3064 chandransh 8220 
class getOrdersForTransaction_args:
494 rajveer 8221 
  """
8222 
  Attributes:
3064 chandransh 8223 
   - transactionId
8224 
   - customerId
494 rajveer 8225 
  """
8226 
 
8227 
  thrift_spec = (
8228 
    None, # 0
3064 chandransh 8229 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8230 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8231 
  )
8232 
 
3064 chandransh 8233 
  def __init__(self, transactionId=None, customerId=None,):
8234 
    self.transactionId = transactionId
8235 
    self.customerId = customerId
494 rajveer 8236 
 
8237 
  def read(self, iprot):
8238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8240 
      return
8241 
    iprot.readStructBegin()
8242 
    while True:
8243 
      (fname, ftype, fid) = iprot.readFieldBegin()
8244 
      if ftype == TType.STOP:
8245 
        break
8246 
      if fid == 1:
8247 
        if ftype == TType.I64:
3064 chandransh 8248 
          self.transactionId = iprot.readI64();
494 rajveer 8249 
        else:
8250 
          iprot.skip(ftype)
8251 
      elif fid == 2:
3064 chandransh 8252 
        if ftype == TType.I64:
8253 
          self.customerId = iprot.readI64();
494 rajveer 8254 
        else:
8255 
          iprot.skip(ftype)
8256 
      else:
8257 
        iprot.skip(ftype)
8258 
      iprot.readFieldEnd()
8259 
    iprot.readStructEnd()
8260 
 
8261 
  def write(self, oprot):
8262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8264 
      return
3064 chandransh 8265 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8266 
    if self.transactionId is not None:
3064 chandransh 8267 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8268 
      oprot.writeI64(self.transactionId)
494 rajveer 8269 
      oprot.writeFieldEnd()
3431 rajveer 8270 
    if self.customerId is not None:
3064 chandransh 8271 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8272 
      oprot.writeI64(self.customerId)
494 rajveer 8273 
      oprot.writeFieldEnd()
8274 
    oprot.writeFieldStop()
8275 
    oprot.writeStructEnd()
8276 
 
3431 rajveer 8277 
  def validate(self):
8278 
    return
8279 
 
8280 
 
494 rajveer 8281 
  def __repr__(self):
8282 
    L = ['%s=%r' % (key, value)
8283 
      for key, value in self.__dict__.iteritems()]
8284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8285 
 
8286 
  def __eq__(self, other):
8287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8288 
 
8289 
  def __ne__(self, other):
8290 
    return not (self == other)
8291 
 
3064 chandransh 8292 
class getOrdersForTransaction_result:
494 rajveer 8293 
  """
8294 
  Attributes:
8295 
   - success
8296 
   - ex
8297 
  """
8298 
 
8299 
  thrift_spec = (
3064 chandransh 8300 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8302 
  )
8303 
 
8304 
  def __init__(self, success=None, ex=None,):
8305 
    self.success = success
8306 
    self.ex = ex
8307 
 
8308 
  def read(self, iprot):
8309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8311 
      return
8312 
    iprot.readStructBegin()
8313 
    while True:
8314 
      (fname, ftype, fid) = iprot.readFieldBegin()
8315 
      if ftype == TType.STOP:
8316 
        break
8317 
      if fid == 0:
3064 chandransh 8318 
        if ftype == TType.LIST:
8319 
          self.success = []
4133 chandransh 8320 
          (_etype87, _size84) = iprot.readListBegin()
8321 
          for _i88 in xrange(_size84):
8322 
            _elem89 = Order()
8323 
            _elem89.read(iprot)
8324 
            self.success.append(_elem89)
3064 chandransh 8325 
          iprot.readListEnd()
494 rajveer 8326 
        else:
8327 
          iprot.skip(ftype)
8328 
      elif fid == 1:
8329 
        if ftype == TType.STRUCT:
8330 
          self.ex = TransactionServiceException()
8331 
          self.ex.read(iprot)
8332 
        else:
8333 
          iprot.skip(ftype)
8334 
      else:
8335 
        iprot.skip(ftype)
8336 
      iprot.readFieldEnd()
8337 
    iprot.readStructEnd()
8338 
 
8339 
  def write(self, oprot):
8340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8342 
      return
3064 chandransh 8343 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8344 
    if self.success is not None:
3064 chandransh 8345 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8346 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8347 
      for iter90 in self.success:
8348 
        iter90.write(oprot)
3064 chandransh 8349 
      oprot.writeListEnd()
494 rajveer 8350 
      oprot.writeFieldEnd()
3431 rajveer 8351 
    if self.ex is not None:
494 rajveer 8352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8353 
      self.ex.write(oprot)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
3431 rajveer 8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
494 rajveer 8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
3064 chandransh 8373 
class getOrdersForCustomer_args:
1149 chandransh 8374 
  """
8375 
  Attributes:
3064 chandransh 8376 
   - customerId
8377 
   - from_date
8378 
   - to_date
8379 
   - statuses
1149 chandransh 8380 
  """
8381 
 
8382 
  thrift_spec = (
8383 
    None, # 0
3064 chandransh 8384 
    (1, TType.I64, 'customerId', None, None, ), # 1
8385 
    (2, TType.I64, 'from_date', None, None, ), # 2
8386 
    (3, TType.I64, 'to_date', None, None, ), # 3
8387 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8388 
  )
8389 
 
3064 chandransh 8390 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8391 
    self.customerId = customerId
8392 
    self.from_date = from_date
8393 
    self.to_date = to_date
8394 
    self.statuses = statuses
1149 chandransh 8395 
 
8396 
  def read(self, iprot):
8397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8399 
      return
8400 
    iprot.readStructBegin()
8401 
    while True:
8402 
      (fname, ftype, fid) = iprot.readFieldBegin()
8403 
      if ftype == TType.STOP:
8404 
        break
8405 
      if fid == 1:
8406 
        if ftype == TType.I64:
3064 chandransh 8407 
          self.customerId = iprot.readI64();
1149 chandransh 8408 
        else:
8409 
          iprot.skip(ftype)
8410 
      elif fid == 2:
8411 
        if ftype == TType.I64:
3064 chandransh 8412 
          self.from_date = iprot.readI64();
1149 chandransh 8413 
        else:
8414 
          iprot.skip(ftype)
2783 chandransh 8415 
      elif fid == 3:
8416 
        if ftype == TType.I64:
3064 chandransh 8417 
          self.to_date = iprot.readI64();
2783 chandransh 8418 
        else:
8419 
          iprot.skip(ftype)
8420 
      elif fid == 4:
3064 chandransh 8421 
        if ftype == TType.LIST:
8422 
          self.statuses = []
4133 chandransh 8423 
          (_etype94, _size91) = iprot.readListBegin()
8424 
          for _i95 in xrange(_size91):
8425 
            _elem96 = iprot.readI32();
8426 
            self.statuses.append(_elem96)
3064 chandransh 8427 
          iprot.readListEnd()
2783 chandransh 8428 
        else:
8429 
          iprot.skip(ftype)
1149 chandransh 8430 
      else:
8431 
        iprot.skip(ftype)
8432 
      iprot.readFieldEnd()
8433 
    iprot.readStructEnd()
8434 
 
8435 
  def write(self, oprot):
8436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8438 
      return
3064 chandransh 8439 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8440 
    if self.customerId is not None:
3064 chandransh 8441 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8442 
      oprot.writeI64(self.customerId)
1149 chandransh 8443 
      oprot.writeFieldEnd()
3431 rajveer 8444 
    if self.from_date is not None:
3064 chandransh 8445 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8446 
      oprot.writeI64(self.from_date)
1149 chandransh 8447 
      oprot.writeFieldEnd()
3431 rajveer 8448 
    if self.to_date is not None:
3064 chandransh 8449 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8450 
      oprot.writeI64(self.to_date)
2783 chandransh 8451 
      oprot.writeFieldEnd()
3431 rajveer 8452 
    if self.statuses is not None:
3064 chandransh 8453 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8454 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8455 
      for iter97 in self.statuses:
8456 
        oprot.writeI32(iter97)
3064 chandransh 8457 
      oprot.writeListEnd()
2783 chandransh 8458 
      oprot.writeFieldEnd()
1149 chandransh 8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
3431 rajveer 8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
1149 chandransh 8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
3064 chandransh 8477 
class getOrdersForCustomer_result:
1149 chandransh 8478 
  """
8479 
  Attributes:
8480 
   - success
8481 
   - ex
8482 
  """
8483 
 
8484 
  thrift_spec = (
3064 chandransh 8485 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8487 
  )
8488 
 
8489 
  def __init__(self, success=None, ex=None,):
8490 
    self.success = success
8491 
    self.ex = ex
8492 
 
8493 
  def read(self, iprot):
8494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8496 
      return
8497 
    iprot.readStructBegin()
8498 
    while True:
8499 
      (fname, ftype, fid) = iprot.readFieldBegin()
8500 
      if ftype == TType.STOP:
8501 
        break
8502 
      if fid == 0:
3064 chandransh 8503 
        if ftype == TType.LIST:
8504 
          self.success = []
4133 chandransh 8505 
          (_etype101, _size98) = iprot.readListBegin()
8506 
          for _i102 in xrange(_size98):
8507 
            _elem103 = Order()
8508 
            _elem103.read(iprot)
8509 
            self.success.append(_elem103)
3064 chandransh 8510 
          iprot.readListEnd()
1149 chandransh 8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.ex = TransactionServiceException()
8516 
          self.ex.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
3064 chandransh 8528 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8529 
    if self.success is not None:
3064 chandransh 8530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8532 
      for iter104 in self.success:
8533 
        iter104.write(oprot)
3064 chandransh 8534 
      oprot.writeListEnd()
1149 chandransh 8535 
      oprot.writeFieldEnd()
3431 rajveer 8536 
    if self.ex is not None:
1149 chandransh 8537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8538 
      self.ex.write(oprot)
8539 
      oprot.writeFieldEnd()
8540 
    oprot.writeFieldStop()
8541 
    oprot.writeStructEnd()
8542 
 
3431 rajveer 8543 
  def validate(self):
8544 
    return
8545 
 
8546 
 
1149 chandransh 8547 
  def __repr__(self):
8548 
    L = ['%s=%r' % (key, value)
8549 
      for key, value in self.__dict__.iteritems()]
8550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8551 
 
8552 
  def __eq__(self, other):
8553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8554 
 
8555 
  def __ne__(self, other):
8556 
    return not (self == other)
8557 
 
3064 chandransh 8558 
class createOrder_args:
921 rajveer 8559 
  """
8560 
  Attributes:
3064 chandransh 8561 
   - order
921 rajveer 8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    None, # 0
3064 chandransh 8566 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8567 
  )
8568 
 
3064 chandransh 8569 
  def __init__(self, order=None,):
8570 
    self.order = order
921 rajveer 8571 
 
8572 
  def read(self, iprot):
8573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8575 
      return
8576 
    iprot.readStructBegin()
8577 
    while True:
8578 
      (fname, ftype, fid) = iprot.readFieldBegin()
8579 
      if ftype == TType.STOP:
8580 
        break
8581 
      if fid == 1:
3064 chandransh 8582 
        if ftype == TType.STRUCT:
8583 
          self.order = Order()
8584 
          self.order.read(iprot)
921 rajveer 8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      else:
8588 
        iprot.skip(ftype)
8589 
      iprot.readFieldEnd()
8590 
    iprot.readStructEnd()
8591 
 
8592 
  def write(self, oprot):
8593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8595 
      return
3064 chandransh 8596 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8597 
    if self.order is not None:
3064 chandransh 8598 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8599 
      self.order.write(oprot)
921 rajveer 8600 
      oprot.writeFieldEnd()
8601 
    oprot.writeFieldStop()
8602 
    oprot.writeStructEnd()
8603 
 
3431 rajveer 8604 
  def validate(self):
8605 
    return
8606 
 
8607 
 
921 rajveer 8608 
  def __repr__(self):
8609 
    L = ['%s=%r' % (key, value)
8610 
      for key, value in self.__dict__.iteritems()]
8611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8612 
 
8613 
  def __eq__(self, other):
8614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8615 
 
8616 
  def __ne__(self, other):
8617 
    return not (self == other)
8618 
 
3064 chandransh 8619 
class createOrder_result:
921 rajveer 8620 
  """
8621 
  Attributes:
8622 
   - success
8623 
   - ex
8624 
  """
8625 
 
8626 
  thrift_spec = (
3064 chandransh 8627 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8629 
  )
8630 
 
8631 
  def __init__(self, success=None, ex=None,):
8632 
    self.success = success
8633 
    self.ex = ex
8634 
 
8635 
  def read(self, iprot):
8636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8638 
      return
8639 
    iprot.readStructBegin()
8640 
    while True:
8641 
      (fname, ftype, fid) = iprot.readFieldBegin()
8642 
      if ftype == TType.STOP:
8643 
        break
8644 
      if fid == 0:
3064 chandransh 8645 
        if ftype == TType.I64:
8646 
          self.success = iprot.readI64();
921 rajveer 8647 
        else:
8648 
          iprot.skip(ftype)
8649 
      elif fid == 1:
8650 
        if ftype == TType.STRUCT:
8651 
          self.ex = TransactionServiceException()
8652 
          self.ex.read(iprot)
8653 
        else:
8654 
          iprot.skip(ftype)
8655 
      else:
8656 
        iprot.skip(ftype)
8657 
      iprot.readFieldEnd()
8658 
    iprot.readStructEnd()
8659 
 
8660 
  def write(self, oprot):
8661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8663 
      return
3064 chandransh 8664 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8665 
    if self.success is not None:
3064 chandransh 8666 
      oprot.writeFieldBegin('success', TType.I64, 0)
8667 
      oprot.writeI64(self.success)
921 rajveer 8668 
      oprot.writeFieldEnd()
3431 rajveer 8669 
    if self.ex is not None:
921 rajveer 8670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8671 
      self.ex.write(oprot)
8672 
      oprot.writeFieldEnd()
8673 
    oprot.writeFieldStop()
8674 
    oprot.writeStructEnd()
8675 
 
3431 rajveer 8676 
  def validate(self):
8677 
    return
8678 
 
8679 
 
921 rajveer 8680 
  def __repr__(self):
8681 
    L = ['%s=%r' % (key, value)
8682 
      for key, value in self.__dict__.iteritems()]
8683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8684 
 
8685 
  def __eq__(self, other):
8686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8687 
 
8688 
  def __ne__(self, other):
8689 
    return not (self == other)
8690 
 
3064 chandransh 8691 
class getOrder_args:
921 rajveer 8692 
  """
8693 
  Attributes:
3064 chandransh 8694 
   - id
921 rajveer 8695 
  """
8696 
 
8697 
  thrift_spec = (
8698 
    None, # 0
3064 chandransh 8699 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8700 
  )
8701 
 
3064 chandransh 8702 
  def __init__(self, id=None,):
8703 
    self.id = id
921 rajveer 8704 
 
8705 
  def read(self, iprot):
8706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8708 
      return
8709 
    iprot.readStructBegin()
8710 
    while True:
8711 
      (fname, ftype, fid) = iprot.readFieldBegin()
8712 
      if ftype == TType.STOP:
8713 
        break
8714 
      if fid == 1:
8715 
        if ftype == TType.I64:
3064 chandransh 8716 
          self.id = iprot.readI64();
921 rajveer 8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      else:
8720 
        iprot.skip(ftype)
8721 
      iprot.readFieldEnd()
8722 
    iprot.readStructEnd()
8723 
 
8724 
  def write(self, oprot):
8725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8727 
      return
3064 chandransh 8728 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8729 
    if self.id is not None:
3064 chandransh 8730 
      oprot.writeFieldBegin('id', TType.I64, 1)
8731 
      oprot.writeI64(self.id)
921 rajveer 8732 
      oprot.writeFieldEnd()
8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
3431 rajveer 8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
921 rajveer 8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
3064 chandransh 8751 
class getOrder_result:
921 rajveer 8752 
  """
8753 
  Attributes:
8754 
   - success
8755 
   - ex
8756 
  """
8757 
 
8758 
  thrift_spec = (
3064 chandransh 8759 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8761 
  )
8762 
 
8763 
  def __init__(self, success=None, ex=None,):
8764 
    self.success = success
8765 
    self.ex = ex
8766 
 
8767 
  def read(self, iprot):
8768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8770 
      return
8771 
    iprot.readStructBegin()
8772 
    while True:
8773 
      (fname, ftype, fid) = iprot.readFieldBegin()
8774 
      if ftype == TType.STOP:
8775 
        break
8776 
      if fid == 0:
3064 chandransh 8777 
        if ftype == TType.STRUCT:
8778 
          self.success = Order()
8779 
          self.success.read(iprot)
921 rajveer 8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      elif fid == 1:
8783 
        if ftype == TType.STRUCT:
8784 
          self.ex = TransactionServiceException()
8785 
          self.ex.read(iprot)
8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
3064 chandransh 8797 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8798 
    if self.success is not None:
3064 chandransh 8799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8800 
      self.success.write(oprot)
921 rajveer 8801 
      oprot.writeFieldEnd()
3431 rajveer 8802 
    if self.ex is not None:
921 rajveer 8803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8804 
      self.ex.write(oprot)
8805 
      oprot.writeFieldEnd()
8806 
    oprot.writeFieldStop()
8807 
    oprot.writeStructEnd()
8808 
 
3431 rajveer 8809 
  def validate(self):
8810 
    return
8811 
 
8812 
 
921 rajveer 8813 
  def __repr__(self):
8814 
    L = ['%s=%r' % (key, value)
8815 
      for key, value in self.__dict__.iteritems()]
8816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8817 
 
8818 
  def __eq__(self, other):
8819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8820 
 
8821 
  def __ne__(self, other):
8822 
    return not (self == other)
8823 
 
3064 chandransh 8824 
class getLineItemsForOrder_args:
94 ashish 8825 
  """
8826 
  Attributes:
3064 chandransh 8827 
   - orderId
94 ashish 8828 
  """
8829 
 
8830 
  thrift_spec = (
8831 
    None, # 0
3064 chandransh 8832 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8833 
  )
8834 
 
3064 chandransh 8835 
  def __init__(self, orderId=None,):
8836 
    self.orderId = orderId
94 ashish 8837 
 
8838 
  def read(self, iprot):
8839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8841 
      return
8842 
    iprot.readStructBegin()
8843 
    while True:
8844 
      (fname, ftype, fid) = iprot.readFieldBegin()
8845 
      if ftype == TType.STOP:
8846 
        break
8847 
      if fid == 1:
8848 
        if ftype == TType.I64:
3064 chandransh 8849 
          self.orderId = iprot.readI64();
94 ashish 8850 
        else:
8851 
          iprot.skip(ftype)
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
3064 chandransh 8861 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8862 
    if self.orderId is not None:
3064 chandransh 8863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8864 
      oprot.writeI64(self.orderId)
94 ashish 8865 
      oprot.writeFieldEnd()
8866 
    oprot.writeFieldStop()
8867 
    oprot.writeStructEnd()
8868 
 
3431 rajveer 8869 
  def validate(self):
8870 
    return
8871 
 
8872 
 
94 ashish 8873 
  def __repr__(self):
8874 
    L = ['%s=%r' % (key, value)
8875 
      for key, value in self.__dict__.iteritems()]
8876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8877 
 
8878 
  def __eq__(self, other):
8879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8880 
 
8881 
  def __ne__(self, other):
8882 
    return not (self == other)
8883 
 
3064 chandransh 8884 
class getLineItemsForOrder_result:
94 ashish 8885 
  """
8886 
  Attributes:
8887 
   - success
8888 
   - ex
8889 
  """
8890 
 
8891 
  thrift_spec = (
3064 chandransh 8892 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8894 
  )
8895 
 
8896 
  def __init__(self, success=None, ex=None,):
8897 
    self.success = success
8898 
    self.ex = ex
8899 
 
8900 
  def read(self, iprot):
8901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8903 
      return
8904 
    iprot.readStructBegin()
8905 
    while True:
8906 
      (fname, ftype, fid) = iprot.readFieldBegin()
8907 
      if ftype == TType.STOP:
8908 
        break
8909 
      if fid == 0:
483 rajveer 8910 
        if ftype == TType.LIST:
8911 
          self.success = []
4133 chandransh 8912 
          (_etype108, _size105) = iprot.readListBegin()
8913 
          for _i109 in xrange(_size105):
8914 
            _elem110 = LineItem()
8915 
            _elem110.read(iprot)
8916 
            self.success.append(_elem110)
483 rajveer 8917 
          iprot.readListEnd()
94 ashish 8918 
        else:
8919 
          iprot.skip(ftype)
8920 
      elif fid == 1:
8921 
        if ftype == TType.STRUCT:
8922 
          self.ex = TransactionServiceException()
8923 
          self.ex.read(iprot)
8924 
        else:
8925 
          iprot.skip(ftype)
8926 
      else:
8927 
        iprot.skip(ftype)
8928 
      iprot.readFieldEnd()
8929 
    iprot.readStructEnd()
8930 
 
8931 
  def write(self, oprot):
8932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8934 
      return
3064 chandransh 8935 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8936 
    if self.success is not None:
483 rajveer 8937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8939 
      for iter111 in self.success:
8940 
        iter111.write(oprot)
483 rajveer 8941 
      oprot.writeListEnd()
94 ashish 8942 
      oprot.writeFieldEnd()
3431 rajveer 8943 
    if self.ex is not None:
94 ashish 8944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8945 
      self.ex.write(oprot)
8946 
      oprot.writeFieldEnd()
8947 
    oprot.writeFieldStop()
8948 
    oprot.writeStructEnd()
8949 
 
3431 rajveer 8950 
  def validate(self):
8951 
    return
8952 
 
8953 
 
94 ashish 8954 
  def __repr__(self):
8955 
    L = ['%s=%r' % (key, value)
8956 
      for key, value in self.__dict__.iteritems()]
8957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8958 
 
8959 
  def __eq__(self, other):
8960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8961 
 
8962 
  def __ne__(self, other):
8963 
    return not (self == other)
8964 
 
3064 chandransh 8965 
class getOrderForCustomer_args:
94 ashish 8966 
  """
8967 
  Attributes:
3064 chandransh 8968 
   - orderId
483 rajveer 8969 
   - customerId
94 ashish 8970 
  """
8971 
 
8972 
  thrift_spec = (
8973 
    None, # 0
3064 chandransh 8974 
    (1, TType.I64, 'orderId', None, None, ), # 1
8975 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8976 
  )
8977 
 
3064 chandransh 8978 
  def __init__(self, orderId=None, customerId=None,):
8979 
    self.orderId = orderId
483 rajveer 8980 
    self.customerId = customerId
94 ashish 8981 
 
8982 
  def read(self, iprot):
8983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8985 
      return
8986 
    iprot.readStructBegin()
8987 
    while True:
8988 
      (fname, ftype, fid) = iprot.readFieldBegin()
8989 
      if ftype == TType.STOP:
8990 
        break
8991 
      if fid == 1:
8992 
        if ftype == TType.I64:
3064 chandransh 8993 
          self.orderId = iprot.readI64();
94 ashish 8994 
        else:
8995 
          iprot.skip(ftype)
8996 
      elif fid == 2:
8997 
        if ftype == TType.I64:
3064 chandransh 8998 
          self.customerId = iprot.readI64();
94 ashish 8999 
        else:
9000 
          iprot.skip(ftype)
9001 
      else:
9002 
        iprot.skip(ftype)
9003 
      iprot.readFieldEnd()
9004 
    iprot.readStructEnd()
9005 
 
9006 
  def write(self, oprot):
9007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9009 
      return
3064 chandransh 9010 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9011 
    if self.orderId is not None:
3064 chandransh 9012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9013 
      oprot.writeI64(self.orderId)
9014 
      oprot.writeFieldEnd()
3431 rajveer 9015 
    if self.customerId is not None:
3064 chandransh 9016 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9017 
      oprot.writeI64(self.customerId)
94 ashish 9018 
      oprot.writeFieldEnd()
9019 
    oprot.writeFieldStop()
9020 
    oprot.writeStructEnd()
9021 
 
3431 rajveer 9022 
  def validate(self):
9023 
    return
9024 
 
9025 
 
94 ashish 9026 
  def __repr__(self):
9027 
    L = ['%s=%r' % (key, value)
9028 
      for key, value in self.__dict__.iteritems()]
9029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9030 
 
9031 
  def __eq__(self, other):
9032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9033 
 
9034 
  def __ne__(self, other):
9035 
    return not (self == other)
9036 
 
3064 chandransh 9037 
class getOrderForCustomer_result:
94 ashish 9038 
  """
9039 
  Attributes:
9040 
   - success
9041 
   - ex
9042 
  """
9043 
 
9044 
  thrift_spec = (
3064 chandransh 9045 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9046 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9047 
  )
9048 
 
9049 
  def __init__(self, success=None, ex=None,):
9050 
    self.success = success
9051 
    self.ex = ex
9052 
 
9053 
  def read(self, iprot):
9054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9056 
      return
9057 
    iprot.readStructBegin()
9058 
    while True:
9059 
      (fname, ftype, fid) = iprot.readFieldBegin()
9060 
      if ftype == TType.STOP:
9061 
        break
9062 
      if fid == 0:
3064 chandransh 9063 
        if ftype == TType.STRUCT:
9064 
          self.success = Order()
9065 
          self.success.read(iprot)
94 ashish 9066 
        else:
9067 
          iprot.skip(ftype)
9068 
      elif fid == 1:
9069 
        if ftype == TType.STRUCT:
9070 
          self.ex = TransactionServiceException()
9071 
          self.ex.read(iprot)
9072 
        else:
9073 
          iprot.skip(ftype)
9074 
      else:
9075 
        iprot.skip(ftype)
9076 
      iprot.readFieldEnd()
9077 
    iprot.readStructEnd()
9078 
 
9079 
  def write(self, oprot):
9080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9082 
      return
3064 chandransh 9083 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9084 
    if self.success is not None:
3064 chandransh 9085 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9086 
      self.success.write(oprot)
94 ashish 9087 
      oprot.writeFieldEnd()
3431 rajveer 9088 
    if self.ex is not None:
94 ashish 9089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9090 
      self.ex.write(oprot)
9091 
      oprot.writeFieldEnd()
9092 
    oprot.writeFieldStop()
9093 
    oprot.writeStructEnd()
9094 
 
3431 rajveer 9095 
  def validate(self):
9096 
    return
9097 
 
9098 
 
94 ashish 9099 
  def __repr__(self):
9100 
    L = ['%s=%r' % (key, value)
9101 
      for key, value in self.__dict__.iteritems()]
9102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9103 
 
9104 
  def __eq__(self, other):
9105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9106 
 
9107 
  def __ne__(self, other):
9108 
    return not (self == other)
9109 
 
3064 chandransh 9110 
class getAlerts_args:
94 ashish 9111 
  """
9112 
  Attributes:
4394 rajveer 9113 
   - type
4444 rajveer 9114 
   - warehouseId
4394 rajveer 9115 
   - status
9116 
   - timestamp
94 ashish 9117 
  """
9118 
 
9119 
  thrift_spec = (
9120 
    None, # 0
4394 rajveer 9121 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9122 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9123 
    (3, TType.I64, 'status', None, None, ), # 3
9124 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9125 
  )
9126 
 
4444 rajveer 9127 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9128 
    self.type = type
4444 rajveer 9129 
    self.warehouseId = warehouseId
4394 rajveer 9130 
    self.status = status
9131 
    self.timestamp = timestamp
94 ashish 9132 
 
9133 
  def read(self, iprot):
9134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9136 
      return
9137 
    iprot.readStructBegin()
9138 
    while True:
9139 
      (fname, ftype, fid) = iprot.readFieldBegin()
9140 
      if ftype == TType.STOP:
9141 
        break
9142 
      if fid == 1:
3064 chandransh 9143 
        if ftype == TType.I64:
4394 rajveer 9144 
          self.type = iprot.readI64();
94 ashish 9145 
        else:
9146 
          iprot.skip(ftype)
3064 chandransh 9147 
      elif fid == 2:
4394 rajveer 9148 
        if ftype == TType.I64:
4444 rajveer 9149 
          self.warehouseId = iprot.readI64();
3064 chandransh 9150 
        else:
9151 
          iprot.skip(ftype)
4394 rajveer 9152 
      elif fid == 3:
9153 
        if ftype == TType.I64:
4444 rajveer 9154 
          self.status = iprot.readI64();
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      elif fid == 4:
9158 
        if ftype == TType.I64:
4394 rajveer 9159 
          self.timestamp = iprot.readI64();
9160 
        else:
9161 
          iprot.skip(ftype)
94 ashish 9162 
      else:
9163 
        iprot.skip(ftype)
9164 
      iprot.readFieldEnd()
9165 
    iprot.readStructEnd()
9166 
 
9167 
  def write(self, oprot):
9168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9170 
      return
3064 chandransh 9171 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9172 
    if self.type is not None:
9173 
      oprot.writeFieldBegin('type', TType.I64, 1)
9174 
      oprot.writeI64(self.type)
94 ashish 9175 
      oprot.writeFieldEnd()
4444 rajveer 9176 
    if self.warehouseId is not None:
9177 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9178 
      oprot.writeI64(self.warehouseId)
9179 
      oprot.writeFieldEnd()
4394 rajveer 9180 
    if self.status is not None:
4444 rajveer 9181 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9182 
      oprot.writeI64(self.status)
3064 chandransh 9183 
      oprot.writeFieldEnd()
4394 rajveer 9184 
    if self.timestamp is not None:
4444 rajveer 9185 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9186 
      oprot.writeI64(self.timestamp)
9187 
      oprot.writeFieldEnd()
94 ashish 9188 
    oprot.writeFieldStop()
9189 
    oprot.writeStructEnd()
9190 
 
3431 rajveer 9191 
  def validate(self):
9192 
    return
9193 
 
9194 
 
94 ashish 9195 
  def __repr__(self):
9196 
    L = ['%s=%r' % (key, value)
9197 
      for key, value in self.__dict__.iteritems()]
9198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9199 
 
9200 
  def __eq__(self, other):
9201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9202 
 
9203 
  def __ne__(self, other):
9204 
    return not (self == other)
9205 
 
3064 chandransh 9206 
class getAlerts_result:
94 ashish 9207 
  """
9208 
  Attributes:
9209 
   - success
9210 
  """
9211 
 
9212 
  thrift_spec = (
3064 chandransh 9213 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9214 
  )
9215 
 
3064 chandransh 9216 
  def __init__(self, success=None,):
94 ashish 9217 
    self.success = success
9218 
 
9219 
  def read(self, iprot):
9220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9222 
      return
9223 
    iprot.readStructBegin()
9224 
    while True:
9225 
      (fname, ftype, fid) = iprot.readFieldBegin()
9226 
      if ftype == TType.STOP:
9227 
        break
9228 
      if fid == 0:
3064 chandransh 9229 
        if ftype == TType.LIST:
9230 
          self.success = []
4133 chandransh 9231 
          (_etype115, _size112) = iprot.readListBegin()
9232 
          for _i116 in xrange(_size112):
9233 
            _elem117 = Alert()
9234 
            _elem117.read(iprot)
9235 
            self.success.append(_elem117)
3064 chandransh 9236 
          iprot.readListEnd()
94 ashish 9237 
        else:
9238 
          iprot.skip(ftype)
9239 
      else:
9240 
        iprot.skip(ftype)
9241 
      iprot.readFieldEnd()
9242 
    iprot.readStructEnd()
9243 
 
9244 
  def write(self, oprot):
9245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9247 
      return
3064 chandransh 9248 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9249 
    if self.success is not None:
3064 chandransh 9250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9252 
      for iter118 in self.success:
9253 
        iter118.write(oprot)
3064 chandransh 9254 
      oprot.writeListEnd()
94 ashish 9255 
      oprot.writeFieldEnd()
9256 
    oprot.writeFieldStop()
9257 
    oprot.writeStructEnd()
9258 
 
3431 rajveer 9259 
  def validate(self):
9260 
    return
9261 
 
9262 
 
94 ashish 9263 
  def __repr__(self):
9264 
    L = ['%s=%r' % (key, value)
9265 
      for key, value in self.__dict__.iteritems()]
9266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9267 
 
9268 
  def __eq__(self, other):
9269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9270 
 
9271 
  def __ne__(self, other):
9272 
    return not (self == other)
9273 
 
4394 rajveer 9274 
class addAlert_args:
94 ashish 9275 
  """
9276 
  Attributes:
3064 chandransh 9277 
   - type
4444 rajveer 9278 
   - warehouseId
4394 rajveer 9279 
   - description
94 ashish 9280 
  """
9281 
 
9282 
  thrift_spec = (
9283 
    None, # 0
4394 rajveer 9284 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9285 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9286 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9287 
  )
9288 
 
4444 rajveer 9289 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9290 
    self.type = type
4444 rajveer 9291 
    self.warehouseId = warehouseId
4394 rajveer 9292 
    self.description = description
94 ashish 9293 
 
9294 
  def read(self, iprot):
9295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9297 
      return
9298 
    iprot.readStructBegin()
9299 
    while True:
9300 
      (fname, ftype, fid) = iprot.readFieldBegin()
9301 
      if ftype == TType.STOP:
9302 
        break
9303 
      if fid == 1:
9304 
        if ftype == TType.I64:
4394 rajveer 9305 
          self.type = iprot.readI64();
94 ashish 9306 
        else:
9307 
          iprot.skip(ftype)
3064 chandransh 9308 
      elif fid == 2:
4444 rajveer 9309 
        if ftype == TType.I64:
9310 
          self.warehouseId = iprot.readI64();
9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      elif fid == 3:
3064 chandransh 9314 
        if ftype == TType.STRING:
4394 rajveer 9315 
          self.description = iprot.readString();
3064 chandransh 9316 
        else:
9317 
          iprot.skip(ftype)
94 ashish 9318 
      else:
9319 
        iprot.skip(ftype)
9320 
      iprot.readFieldEnd()
9321 
    iprot.readStructEnd()
9322 
 
9323 
  def write(self, oprot):
9324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9326 
      return
4394 rajveer 9327 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9328 
    if self.type is not None:
4394 rajveer 9329 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9330 
      oprot.writeI64(self.type)
9331 
      oprot.writeFieldEnd()
4444 rajveer 9332 
    if self.warehouseId is not None:
9333 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9334 
      oprot.writeI64(self.warehouseId)
9335 
      oprot.writeFieldEnd()
4394 rajveer 9336 
    if self.description is not None:
4444 rajveer 9337 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9338 
      oprot.writeString(self.description)
3064 chandransh 9339 
      oprot.writeFieldEnd()
94 ashish 9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
94 ashish 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
4394 rajveer 9358 
class addAlert_result:
3064 chandransh 9359 
 
9360 
  thrift_spec = (
9361 
  )
9362 
 
9363 
  def read(self, iprot):
9364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9366 
      return
9367 
    iprot.readStructBegin()
9368 
    while True:
9369 
      (fname, ftype, fid) = iprot.readFieldBegin()
9370 
      if ftype == TType.STOP:
9371 
        break
9372 
      else:
9373 
        iprot.skip(ftype)
9374 
      iprot.readFieldEnd()
9375 
    iprot.readStructEnd()
9376 
 
9377 
  def write(self, oprot):
9378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9380 
      return
4394 rajveer 9381 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9382 
    oprot.writeFieldStop()
9383 
    oprot.writeStructEnd()
9384 
 
3431 rajveer 9385 
  def validate(self):
9386 
    return
9387 
 
9388 
 
3064 chandransh 9389 
  def __repr__(self):
9390 
    L = ['%s=%r' % (key, value)
9391 
      for key, value in self.__dict__.iteritems()]
9392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9393 
 
9394 
  def __eq__(self, other):
9395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9396 
 
9397 
  def __ne__(self, other):
9398 
    return not (self == other)
9399 
 
4444 rajveer 9400 
class markAlertsAsSeen_args:
9401 
  """
9402 
  Attributes:
9403 
   - warehouseId
9404 
  """
9405 
 
9406 
  thrift_spec = (
9407 
    None, # 0
9408 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9409 
  )
9410 
 
9411 
  def __init__(self, warehouseId=None,):
9412 
    self.warehouseId = warehouseId
9413 
 
9414 
  def read(self, iprot):
9415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9417 
      return
9418 
    iprot.readStructBegin()
9419 
    while True:
9420 
      (fname, ftype, fid) = iprot.readFieldBegin()
9421 
      if ftype == TType.STOP:
9422 
        break
9423 
      if fid == 1:
9424 
        if ftype == TType.I64:
9425 
          self.warehouseId = iprot.readI64();
9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      else:
9429 
        iprot.skip(ftype)
9430 
      iprot.readFieldEnd()
9431 
    iprot.readStructEnd()
9432 
 
9433 
  def write(self, oprot):
9434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9436 
      return
9437 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9438 
    if self.warehouseId is not None:
9439 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9440 
      oprot.writeI64(self.warehouseId)
9441 
      oprot.writeFieldEnd()
9442 
    oprot.writeFieldStop()
9443 
    oprot.writeStructEnd()
9444 
 
9445 
  def validate(self):
9446 
    return
9447 
 
9448 
 
9449 
  def __repr__(self):
9450 
    L = ['%s=%r' % (key, value)
9451 
      for key, value in self.__dict__.iteritems()]
9452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9453 
 
9454 
  def __eq__(self, other):
9455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9456 
 
9457 
  def __ne__(self, other):
9458 
    return not (self == other)
9459 
 
9460 
class markAlertsAsSeen_result:
9461 
 
9462 
  thrift_spec = (
9463 
  )
9464 
 
9465 
  def read(self, iprot):
9466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9468 
      return
9469 
    iprot.readStructBegin()
9470 
    while True:
9471 
      (fname, ftype, fid) = iprot.readFieldBegin()
9472 
      if ftype == TType.STOP:
9473 
        break
9474 
      else:
9475 
        iprot.skip(ftype)
9476 
      iprot.readFieldEnd()
9477 
    iprot.readStructEnd()
9478 
 
9479 
  def write(self, oprot):
9480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9482 
      return
9483 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9484 
    oprot.writeFieldStop()
9485 
    oprot.writeStructEnd()
9486 
 
9487 
  def validate(self):
9488 
    return
9489 
 
9490 
 
9491 
  def __repr__(self):
9492 
    L = ['%s=%r' % (key, value)
9493 
      for key, value in self.__dict__.iteritems()]
9494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9495 
 
9496 
  def __eq__(self, other):
9497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9498 
 
9499 
  def __ne__(self, other):
9500 
    return not (self == other)
9501 
 
3064 chandransh 9502 
class getValidOrderCount_args:
9503 
 
9504 
  thrift_spec = (
9505 
  )
9506 
 
9507 
  def read(self, iprot):
9508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9510 
      return
9511 
    iprot.readStructBegin()
9512 
    while True:
9513 
      (fname, ftype, fid) = iprot.readFieldBegin()
9514 
      if ftype == TType.STOP:
9515 
        break
9516 
      else:
9517 
        iprot.skip(ftype)
9518 
      iprot.readFieldEnd()
9519 
    iprot.readStructEnd()
9520 
 
9521 
  def write(self, oprot):
9522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9524 
      return
9525 
    oprot.writeStructBegin('getValidOrderCount_args')
9526 
    oprot.writeFieldStop()
9527 
    oprot.writeStructEnd()
9528 
 
3431 rajveer 9529 
  def validate(self):
9530 
    return
9531 
 
9532 
 
3064 chandransh 9533 
  def __repr__(self):
9534 
    L = ['%s=%r' % (key, value)
9535 
      for key, value in self.__dict__.iteritems()]
9536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9537 
 
9538 
  def __eq__(self, other):
9539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9540 
 
9541 
  def __ne__(self, other):
9542 
    return not (self == other)
9543 
 
9544 
class getValidOrderCount_result:
94 ashish 9545 
  """
9546 
  Attributes:
9547 
   - success
9548 
  """
9549 
 
9550 
  thrift_spec = (
3064 chandransh 9551 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9552 
  )
9553 
 
3064 chandransh 9554 
  def __init__(self, success=None,):
94 ashish 9555 
    self.success = success
9556 
 
9557 
  def read(self, iprot):
9558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9560 
      return
9561 
    iprot.readStructBegin()
9562 
    while True:
9563 
      (fname, ftype, fid) = iprot.readFieldBegin()
9564 
      if ftype == TType.STOP:
9565 
        break
9566 
      if fid == 0:
3064 chandransh 9567 
        if ftype == TType.I64:
9568 
          self.success = iprot.readI64();
94 ashish 9569 
        else:
9570 
          iprot.skip(ftype)
9571 
      else:
9572 
        iprot.skip(ftype)
9573 
      iprot.readFieldEnd()
9574 
    iprot.readStructEnd()
9575 
 
9576 
  def write(self, oprot):
9577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9579 
      return
3064 chandransh 9580 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9581 
    if self.success is not None:
3064 chandransh 9582 
      oprot.writeFieldBegin('success', TType.I64, 0)
9583 
      oprot.writeI64(self.success)
94 ashish 9584 
      oprot.writeFieldEnd()
9585 
    oprot.writeFieldStop()
9586 
    oprot.writeStructEnd()
9587 
 
3431 rajveer 9588 
  def validate(self):
9589 
    return
9590 
 
9591 
 
94 ashish 9592 
  def __repr__(self):
9593 
    L = ['%s=%r' % (key, value)
9594 
      for key, value in self.__dict__.iteritems()]
9595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9596 
 
9597 
  def __eq__(self, other):
9598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9599 
 
9600 
  def __ne__(self, other):
9601 
    return not (self == other)
9602 
 
3064 chandransh 9603 
class getNoOfCustomersWithSuccessfulTransaction_args:
9604 
 
9605 
  thrift_spec = (
9606 
  )
9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      else:
9618 
        iprot.skip(ftype)
9619 
      iprot.readFieldEnd()
9620 
    iprot.readStructEnd()
9621 
 
9622 
  def write(self, oprot):
9623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9625 
      return
9626 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9627 
    oprot.writeFieldStop()
9628 
    oprot.writeStructEnd()
9629 
 
3431 rajveer 9630 
  def validate(self):
9631 
    return
9632 
 
9633 
 
3064 chandransh 9634 
  def __repr__(self):
9635 
    L = ['%s=%r' % (key, value)
9636 
      for key, value in self.__dict__.iteritems()]
9637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9638 
 
9639 
  def __eq__(self, other):
9640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9641 
 
9642 
  def __ne__(self, other):
9643 
    return not (self == other)
9644 
 
9645 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9646 
  """
9647 
  Attributes:
3064 chandransh 9648 
   - success
94 ashish 9649 
  """
9650 
 
9651 
  thrift_spec = (
3064 chandransh 9652 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9653 
  )
9654 
 
3064 chandransh 9655 
  def __init__(self, success=None,):
9656 
    self.success = success
94 ashish 9657 
 
9658 
  def read(self, iprot):
9659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9661 
      return
9662 
    iprot.readStructBegin()
9663 
    while True:
9664 
      (fname, ftype, fid) = iprot.readFieldBegin()
9665 
      if ftype == TType.STOP:
9666 
        break
3064 chandransh 9667 
      if fid == 0:
94 ashish 9668 
        if ftype == TType.I64:
3064 chandransh 9669 
          self.success = iprot.readI64();
94 ashish 9670 
        else:
9671 
          iprot.skip(ftype)
9672 
      else:
9673 
        iprot.skip(ftype)
9674 
      iprot.readFieldEnd()
9675 
    iprot.readStructEnd()
9676 
 
9677 
  def write(self, oprot):
9678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9680 
      return
3064 chandransh 9681 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9682 
    if self.success is not None:
3064 chandransh 9683 
      oprot.writeFieldBegin('success', TType.I64, 0)
9684 
      oprot.writeI64(self.success)
94 ashish 9685 
      oprot.writeFieldEnd()
9686 
    oprot.writeFieldStop()
9687 
    oprot.writeStructEnd()
9688 
 
3431 rajveer 9689 
  def validate(self):
9690 
    return
9691 
 
9692 
 
94 ashish 9693 
  def __repr__(self):
9694 
    L = ['%s=%r' % (key, value)
9695 
      for key, value in self.__dict__.iteritems()]
9696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9697 
 
9698 
  def __eq__(self, other):
9699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9700 
 
9701 
  def __ne__(self, other):
9702 
    return not (self == other)
9703 
 
3064 chandransh 9704 
class getValidOrdersAmountRange_args:
9705 
 
9706 
  thrift_spec = (
9707 
  )
9708 
 
9709 
  def read(self, iprot):
9710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9712 
      return
9713 
    iprot.readStructBegin()
9714 
    while True:
9715 
      (fname, ftype, fid) = iprot.readFieldBegin()
9716 
      if ftype == TType.STOP:
9717 
        break
9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
9727 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9728 
    oprot.writeFieldStop()
9729 
    oprot.writeStructEnd()
9730 
 
3431 rajveer 9731 
  def validate(self):
9732 
    return
9733 
 
9734 
 
3064 chandransh 9735 
  def __repr__(self):
9736 
    L = ['%s=%r' % (key, value)
9737 
      for key, value in self.__dict__.iteritems()]
9738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9739 
 
9740 
  def __eq__(self, other):
9741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9742 
 
9743 
  def __ne__(self, other):
9744 
    return not (self == other)
9745 
 
9746 
class getValidOrdersAmountRange_result:
94 ashish 9747 
  """
9748 
  Attributes:
9749 
   - success
9750 
  """
9751 
 
9752 
  thrift_spec = (
3064 chandransh 9753 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9754 
  )
9755 
 
3064 chandransh 9756 
  def __init__(self, success=None,):
94 ashish 9757 
    self.success = success
9758 
 
9759 
  def read(self, iprot):
9760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9762 
      return
9763 
    iprot.readStructBegin()
9764 
    while True:
9765 
      (fname, ftype, fid) = iprot.readFieldBegin()
9766 
      if ftype == TType.STOP:
9767 
        break
9768 
      if fid == 0:
483 rajveer 9769 
        if ftype == TType.LIST:
9770 
          self.success = []
4133 chandransh 9771 
          (_etype122, _size119) = iprot.readListBegin()
9772 
          for _i123 in xrange(_size119):
9773 
            _elem124 = iprot.readDouble();
9774 
            self.success.append(_elem124)
483 rajveer 9775 
          iprot.readListEnd()
94 ashish 9776 
        else:
9777 
          iprot.skip(ftype)
9778 
      else:
9779 
        iprot.skip(ftype)
9780 
      iprot.readFieldEnd()
9781 
    iprot.readStructEnd()
9782 
 
9783 
  def write(self, oprot):
9784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9786 
      return
3064 chandransh 9787 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9788 
    if self.success is not None:
483 rajveer 9789 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9790 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9791 
      for iter125 in self.success:
9792 
        oprot.writeDouble(iter125)
483 rajveer 9793 
      oprot.writeListEnd()
94 ashish 9794 
      oprot.writeFieldEnd()
9795 
    oprot.writeFieldStop()
9796 
    oprot.writeStructEnd()
9797 
 
3431 rajveer 9798 
  def validate(self):
9799 
    return
9800 
 
9801 
 
94 ashish 9802 
  def __repr__(self):
9803 
    L = ['%s=%r' % (key, value)
9804 
      for key, value in self.__dict__.iteritems()]
9805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9806 
 
9807 
  def __eq__(self, other):
9808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9809 
 
9810 
  def __ne__(self, other):
9811 
    return not (self == other)
9812 
 
3064 chandransh 9813 
class getValidOrders_args:
1528 ankur.sing 9814 
  """
9815 
  Attributes:
3064 chandransh 9816 
   - limit
1528 ankur.sing 9817 
  """
9818 
 
9819 
  thrift_spec = (
9820 
    None, # 0
3064 chandransh 9821 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9822 
  )
9823 
 
3064 chandransh 9824 
  def __init__(self, limit=None,):
9825 
    self.limit = limit
1528 ankur.sing 9826 
 
9827 
  def read(self, iprot):
9828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9830 
      return
9831 
    iprot.readStructBegin()
9832 
    while True:
9833 
      (fname, ftype, fid) = iprot.readFieldBegin()
9834 
      if ftype == TType.STOP:
9835 
        break
9836 
      if fid == 1:
9837 
        if ftype == TType.I64:
3064 chandransh 9838 
          self.limit = iprot.readI64();
1528 ankur.sing 9839 
        else:
9840 
          iprot.skip(ftype)
9841 
      else:
9842 
        iprot.skip(ftype)
9843 
      iprot.readFieldEnd()
9844 
    iprot.readStructEnd()
9845 
 
9846 
  def write(self, oprot):
9847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9849 
      return
3064 chandransh 9850 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9851 
    if self.limit is not None:
3064 chandransh 9852 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9853 
      oprot.writeI64(self.limit)
1528 ankur.sing 9854 
      oprot.writeFieldEnd()
9855 
    oprot.writeFieldStop()
9856 
    oprot.writeStructEnd()
9857 
 
3431 rajveer 9858 
  def validate(self):
9859 
    return
9860 
 
9861 
 
1528 ankur.sing 9862 
  def __repr__(self):
9863 
    L = ['%s=%r' % (key, value)
9864 
      for key, value in self.__dict__.iteritems()]
9865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9866 
 
9867 
  def __eq__(self, other):
9868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9869 
 
9870 
  def __ne__(self, other):
9871 
    return not (self == other)
9872 
 
3064 chandransh 9873 
class getValidOrders_result:
1528 ankur.sing 9874 
  """
9875 
  Attributes:
9876 
   - success
9877 
  """
9878 
 
9879 
  thrift_spec = (
3064 chandransh 9880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9881 
  )
9882 
 
3064 chandransh 9883 
  def __init__(self, success=None,):
1528 ankur.sing 9884 
    self.success = success
9885 
 
9886 
  def read(self, iprot):
9887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9889 
      return
9890 
    iprot.readStructBegin()
9891 
    while True:
9892 
      (fname, ftype, fid) = iprot.readFieldBegin()
9893 
      if ftype == TType.STOP:
9894 
        break
9895 
      if fid == 0:
3064 chandransh 9896 
        if ftype == TType.LIST:
9897 
          self.success = []
4133 chandransh 9898 
          (_etype129, _size126) = iprot.readListBegin()
9899 
          for _i130 in xrange(_size126):
9900 
            _elem131 = Order()
9901 
            _elem131.read(iprot)
9902 
            self.success.append(_elem131)
3064 chandransh 9903 
          iprot.readListEnd()
1528 ankur.sing 9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      else:
9907 
        iprot.skip(ftype)
9908 
      iprot.readFieldEnd()
9909 
    iprot.readStructEnd()
9910 
 
9911 
  def write(self, oprot):
9912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9914 
      return
3064 chandransh 9915 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9916 
    if self.success is not None:
3064 chandransh 9917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9919 
      for iter132 in self.success:
9920 
        iter132.write(oprot)
3064 chandransh 9921 
      oprot.writeListEnd()
1528 ankur.sing 9922 
      oprot.writeFieldEnd()
9923 
    oprot.writeFieldStop()
9924 
    oprot.writeStructEnd()
9925 
 
3431 rajveer 9926 
  def validate(self):
9927 
    return
9928 
 
9929 
 
1528 ankur.sing 9930 
  def __repr__(self):
9931 
    L = ['%s=%r' % (key, value)
9932 
      for key, value in self.__dict__.iteritems()]
9933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9934 
 
9935 
  def __eq__(self, other):
9936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9937 
 
9938 
  def __ne__(self, other):
9939 
    return not (self == other)
9940 
 
1220 chandransh 9941 
class batchOrders_args:
9942 
  """
9943 
  Attributes:
9944 
   - warehouseId
9945 
  """
9946 
 
9947 
  thrift_spec = (
9948 
    None, # 0
9949 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9950 
  )
9951 
 
9952 
  def __init__(self, warehouseId=None,):
9953 
    self.warehouseId = warehouseId
9954 
 
9955 
  def read(self, iprot):
9956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9958 
      return
9959 
    iprot.readStructBegin()
9960 
    while True:
9961 
      (fname, ftype, fid) = iprot.readFieldBegin()
9962 
      if ftype == TType.STOP:
9963 
        break
9964 
      if fid == 1:
9965 
        if ftype == TType.I64:
9966 
          self.warehouseId = iprot.readI64();
9967 
        else:
9968 
          iprot.skip(ftype)
9969 
      else:
9970 
        iprot.skip(ftype)
9971 
      iprot.readFieldEnd()
9972 
    iprot.readStructEnd()
9973 
 
9974 
  def write(self, oprot):
9975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9977 
      return
9978 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9979 
    if self.warehouseId is not None:
1220 chandransh 9980 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9981 
      oprot.writeI64(self.warehouseId)
9982 
      oprot.writeFieldEnd()
9983 
    oprot.writeFieldStop()
9984 
    oprot.writeStructEnd()
9985 
 
3431 rajveer 9986 
  def validate(self):
9987 
    return
9988 
 
9989 
 
1220 chandransh 9990 
  def __repr__(self):
9991 
    L = ['%s=%r' % (key, value)
9992 
      for key, value in self.__dict__.iteritems()]
9993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9994 
 
9995 
  def __eq__(self, other):
9996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9997 
 
9998 
  def __ne__(self, other):
9999 
    return not (self == other)
10000 
 
10001 
class batchOrders_result:
10002 
  """
10003 
  Attributes:
10004 
   - success
10005 
   - ex
10006 
  """
10007 
 
10008 
  thrift_spec = (
10009 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10011 
  )
10012 
 
10013 
  def __init__(self, success=None, ex=None,):
10014 
    self.success = success
10015 
    self.ex = ex
10016 
 
10017 
  def read(self, iprot):
10018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10020 
      return
10021 
    iprot.readStructBegin()
10022 
    while True:
10023 
      (fname, ftype, fid) = iprot.readFieldBegin()
10024 
      if ftype == TType.STOP:
10025 
        break
10026 
      if fid == 0:
10027 
        if ftype == TType.LIST:
10028 
          self.success = []
4133 chandransh 10029 
          (_etype136, _size133) = iprot.readListBegin()
10030 
          for _i137 in xrange(_size133):
10031 
            _elem138 = Order()
10032 
            _elem138.read(iprot)
10033 
            self.success.append(_elem138)
1220 chandransh 10034 
          iprot.readListEnd()
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      elif fid == 1:
10038 
        if ftype == TType.STRUCT:
10039 
          self.ex = TransactionServiceException()
10040 
          self.ex.read(iprot)
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      else:
10044 
        iprot.skip(ftype)
10045 
      iprot.readFieldEnd()
10046 
    iprot.readStructEnd()
10047 
 
10048 
  def write(self, oprot):
10049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10051 
      return
10052 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10053 
    if self.success is not None:
1220 chandransh 10054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10055 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10056 
      for iter139 in self.success:
10057 
        iter139.write(oprot)
1220 chandransh 10058 
      oprot.writeListEnd()
10059 
      oprot.writeFieldEnd()
3431 rajveer 10060 
    if self.ex is not None:
1220 chandransh 10061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10062 
      self.ex.write(oprot)
10063 
      oprot.writeFieldEnd()
10064 
    oprot.writeFieldStop()
10065 
    oprot.writeStructEnd()
10066 
 
3431 rajveer 10067 
  def validate(self):
10068 
    return
10069 
 
10070 
 
1220 chandransh 10071 
  def __repr__(self):
10072 
    L = ['%s=%r' % (key, value)
10073 
      for key, value in self.__dict__.iteritems()]
10074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10075 
 
10076 
  def __eq__(self, other):
10077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10078 
 
10079 
  def __ne__(self, other):
10080 
    return not (self == other)
10081 
 
1208 chandransh 10082 
class markOrderAsOutOfStock_args:
10083 
  """
10084 
  Attributes:
10085 
   - orderId
10086 
  """
10087 
 
10088 
  thrift_spec = (
10089 
    None, # 0
10090 
    (1, TType.I64, 'orderId', None, None, ), # 1
10091 
  )
10092 
 
10093 
  def __init__(self, orderId=None,):
10094 
    self.orderId = orderId
10095 
 
10096 
  def read(self, iprot):
10097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10099 
      return
10100 
    iprot.readStructBegin()
10101 
    while True:
10102 
      (fname, ftype, fid) = iprot.readFieldBegin()
10103 
      if ftype == TType.STOP:
10104 
        break
10105 
      if fid == 1:
10106 
        if ftype == TType.I64:
10107 
          self.orderId = iprot.readI64();
10108 
        else:
10109 
          iprot.skip(ftype)
10110 
      else:
10111 
        iprot.skip(ftype)
10112 
      iprot.readFieldEnd()
10113 
    iprot.readStructEnd()
10114 
 
10115 
  def write(self, oprot):
10116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10118 
      return
10119 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10120 
    if self.orderId is not None:
1208 chandransh 10121 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10122 
      oprot.writeI64(self.orderId)
10123 
      oprot.writeFieldEnd()
10124 
    oprot.writeFieldStop()
10125 
    oprot.writeStructEnd()
10126 
 
3431 rajveer 10127 
  def validate(self):
10128 
    return
10129 
 
10130 
 
1208 chandransh 10131 
  def __repr__(self):
10132 
    L = ['%s=%r' % (key, value)
10133 
      for key, value in self.__dict__.iteritems()]
10134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10135 
 
10136 
  def __eq__(self, other):
10137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10138 
 
10139 
  def __ne__(self, other):
10140 
    return not (self == other)
10141 
 
10142 
class markOrderAsOutOfStock_result:
10143 
  """
10144 
  Attributes:
10145 
   - success
10146 
   - ex
10147 
  """
10148 
 
10149 
  thrift_spec = (
10150 
    (0, TType.BOOL, 'success', None, None, ), # 0
10151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10152 
  )
10153 
 
10154 
  def __init__(self, success=None, ex=None,):
10155 
    self.success = success
10156 
    self.ex = ex
10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
10167 
      if fid == 0:
10168 
        if ftype == TType.BOOL:
10169 
          self.success = iprot.readBool();
10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      elif fid == 1:
10173 
        if ftype == TType.STRUCT:
10174 
          self.ex = TransactionServiceException()
10175 
          self.ex.read(iprot)
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10188 
    if self.success is not None:
1208 chandransh 10189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10190 
      oprot.writeBool(self.success)
10191 
      oprot.writeFieldEnd()
3431 rajveer 10192 
    if self.ex is not None:
1208 chandransh 10193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10194 
      self.ex.write(oprot)
10195 
      oprot.writeFieldEnd()
10196 
    oprot.writeFieldStop()
10197 
    oprot.writeStructEnd()
10198 
 
3431 rajveer 10199 
  def validate(self):
10200 
    return
10201 
 
10202 
 
1208 chandransh 10203 
  def __repr__(self):
10204 
    L = ['%s=%r' % (key, value)
10205 
      for key, value in self.__dict__.iteritems()]
10206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10207 
 
10208 
  def __eq__(self, other):
10209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10210 
 
10211 
  def __ne__(self, other):
10212 
    return not (self == other)
10213 
 
3064 chandransh 10214 
class verifyOrder_args:
759 chandransh 10215 
  """
10216 
  Attributes:
3064 chandransh 10217 
   - orderId
759 chandransh 10218 
  """
10219 
 
10220 
  thrift_spec = (
10221 
    None, # 0
3064 chandransh 10222 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10223 
  )
10224 
 
3064 chandransh 10225 
  def __init__(self, orderId=None,):
10226 
    self.orderId = orderId
759 chandransh 10227 
 
10228 
  def read(self, iprot):
10229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10231 
      return
10232 
    iprot.readStructBegin()
10233 
    while True:
10234 
      (fname, ftype, fid) = iprot.readFieldBegin()
10235 
      if ftype == TType.STOP:
10236 
        break
10237 
      if fid == 1:
10238 
        if ftype == TType.I64:
3064 chandransh 10239 
          self.orderId = iprot.readI64();
759 chandransh 10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
3064 chandransh 10251 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10252 
    if self.orderId is not None:
3064 chandransh 10253 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10254 
      oprot.writeI64(self.orderId)
759 chandransh 10255 
      oprot.writeFieldEnd()
10256 
    oprot.writeFieldStop()
10257 
    oprot.writeStructEnd()
10258 
 
3431 rajveer 10259 
  def validate(self):
10260 
    return
10261 
 
10262 
 
759 chandransh 10263 
  def __repr__(self):
10264 
    L = ['%s=%r' % (key, value)
10265 
      for key, value in self.__dict__.iteritems()]
10266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10267 
 
10268 
  def __eq__(self, other):
10269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10270 
 
10271 
  def __ne__(self, other):
10272 
    return not (self == other)
10273 
 
3064 chandransh 10274 
class verifyOrder_result:
759 chandransh 10275 
  """
10276 
  Attributes:
10277 
   - success
10278 
   - ex
10279 
  """
10280 
 
10281 
  thrift_spec = (
10282 
    (0, TType.BOOL, 'success', None, None, ), # 0
10283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10284 
  )
10285 
 
10286 
  def __init__(self, success=None, ex=None,):
10287 
    self.success = success
10288 
    self.ex = ex
10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
10299 
      if fid == 0:
10300 
        if ftype == TType.BOOL:
10301 
          self.success = iprot.readBool();
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      elif fid == 1:
10305 
        if ftype == TType.STRUCT:
10306 
          self.ex = TransactionServiceException()
10307 
          self.ex.read(iprot)
10308 
        else:
10309 
          iprot.skip(ftype)
10310 
      else:
10311 
        iprot.skip(ftype)
10312 
      iprot.readFieldEnd()
10313 
    iprot.readStructEnd()
10314 
 
10315 
  def write(self, oprot):
10316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10318 
      return
3064 chandransh 10319 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10320 
    if self.success is not None:
759 chandransh 10321 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10322 
      oprot.writeBool(self.success)
10323 
      oprot.writeFieldEnd()
3431 rajveer 10324 
    if self.ex is not None:
759 chandransh 10325 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10326 
      self.ex.write(oprot)
10327 
      oprot.writeFieldEnd()
10328 
    oprot.writeFieldStop()
10329 
    oprot.writeStructEnd()
10330 
 
3431 rajveer 10331 
  def validate(self):
10332 
    return
10333 
 
10334 
 
759 chandransh 10335 
  def __repr__(self):
10336 
    L = ['%s=%r' % (key, value)
10337 
      for key, value in self.__dict__.iteritems()]
10338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10339 
 
10340 
  def __eq__(self, other):
10341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10342 
 
10343 
  def __ne__(self, other):
10344 
    return not (self == other)
10345 
 
3064 chandransh 10346 
class acceptOrder_args:
1113 chandransh 10347 
  """
10348 
  Attributes:
3064 chandransh 10349 
   - orderId
1113 chandransh 10350 
  """
10351 
 
10352 
  thrift_spec = (
10353 
    None, # 0
3064 chandransh 10354 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10355 
  )
10356 
 
3064 chandransh 10357 
  def __init__(self, orderId=None,):
10358 
    self.orderId = orderId
1113 chandransh 10359 
 
10360 
  def read(self, iprot):
10361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10363 
      return
10364 
    iprot.readStructBegin()
10365 
    while True:
10366 
      (fname, ftype, fid) = iprot.readFieldBegin()
10367 
      if ftype == TType.STOP:
10368 
        break
10369 
      if fid == 1:
10370 
        if ftype == TType.I64:
3064 chandransh 10371 
          self.orderId = iprot.readI64();
1113 chandransh 10372 
        else:
10373 
          iprot.skip(ftype)
10374 
      else:
10375 
        iprot.skip(ftype)
10376 
      iprot.readFieldEnd()
10377 
    iprot.readStructEnd()
10378 
 
10379 
  def write(self, oprot):
10380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10382 
      return
3064 chandransh 10383 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10384 
    if self.orderId is not None:
3064 chandransh 10385 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10386 
      oprot.writeI64(self.orderId)
1113 chandransh 10387 
      oprot.writeFieldEnd()
10388 
    oprot.writeFieldStop()
10389 
    oprot.writeStructEnd()
10390 
 
3431 rajveer 10391 
  def validate(self):
10392 
    return
10393 
 
10394 
 
1113 chandransh 10395 
  def __repr__(self):
10396 
    L = ['%s=%r' % (key, value)
10397 
      for key, value in self.__dict__.iteritems()]
10398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10399 
 
10400 
  def __eq__(self, other):
10401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10402 
 
10403 
  def __ne__(self, other):
10404 
    return not (self == other)
10405 
 
3064 chandransh 10406 
class acceptOrder_result:
1113 chandransh 10407 
  """
10408 
  Attributes:
10409 
   - success
10410 
   - ex
10411 
  """
10412 
 
10413 
  thrift_spec = (
3064 chandransh 10414 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10416 
  )
10417 
 
10418 
  def __init__(self, success=None, ex=None,):
10419 
    self.success = success
10420 
    self.ex = ex
10421 
 
10422 
  def read(self, iprot):
10423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10425 
      return
10426 
    iprot.readStructBegin()
10427 
    while True:
10428 
      (fname, ftype, fid) = iprot.readFieldBegin()
10429 
      if ftype == TType.STOP:
10430 
        break
10431 
      if fid == 0:
3064 chandransh 10432 
        if ftype == TType.BOOL:
10433 
          self.success = iprot.readBool();
1113 chandransh 10434 
        else:
10435 
          iprot.skip(ftype)
10436 
      elif fid == 1:
10437 
        if ftype == TType.STRUCT:
10438 
          self.ex = TransactionServiceException()
10439 
          self.ex.read(iprot)
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
3064 chandransh 10451 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10452 
    if self.success is not None:
3064 chandransh 10453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10454 
      oprot.writeBool(self.success)
1113 chandransh 10455 
      oprot.writeFieldEnd()
3431 rajveer 10456 
    if self.ex is not None:
1113 chandransh 10457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10458 
      self.ex.write(oprot)
10459 
      oprot.writeFieldEnd()
10460 
    oprot.writeFieldStop()
10461 
    oprot.writeStructEnd()
10462 
 
3431 rajveer 10463 
  def validate(self):
10464 
    return
10465 
 
10466 
 
1113 chandransh 10467 
  def __repr__(self):
10468 
    L = ['%s=%r' % (key, value)
10469 
      for key, value in self.__dict__.iteritems()]
10470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10471 
 
10472 
  def __eq__(self, other):
10473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10474 
 
10475 
  def __ne__(self, other):
10476 
    return not (self == other)
10477 
 
3064 chandransh 10478 
class addBillingDetails_args:
1135 chandransh 10479 
  """
10480 
  Attributes:
3064 chandransh 10481 
   - orderId
10482 
   - invoice_number
4658 mandeep.dh 10483 
   - serialNumber
4283 anupam.sin 10484 
   - itemNumber
3064 chandransh 10485 
   - billed_by
4264 rajveer 10486 
   - jacketNumber
4283 anupam.sin 10487 
   - billingType
10488 
   - vendorId
4763 rajveer 10489 
   - authorize
1135 chandransh 10490 
  """
10491 
 
10492 
  thrift_spec = (
10493 
    None, # 0
3064 chandransh 10494 
    (1, TType.I64, 'orderId', None, None, ), # 1
10495 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10496 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10497 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10498 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10499 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10500 
    (7, TType.I64, 'billingType', None, None, ), # 7
10501 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10502 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10503 
  )
10504 
 
4763 rajveer 10505 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None, authorize=None,):
3064 chandransh 10506 
    self.orderId = orderId
10507 
    self.invoice_number = invoice_number
4658 mandeep.dh 10508 
    self.serialNumber = serialNumber
4283 anupam.sin 10509 
    self.itemNumber = itemNumber
3064 chandransh 10510 
    self.billed_by = billed_by
4264 rajveer 10511 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10512 
    self.billingType = billingType
10513 
    self.vendorId = vendorId
4763 rajveer 10514 
    self.authorize = authorize
1135 chandransh 10515 
 
10516 
  def read(self, iprot):
10517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10519 
      return
10520 
    iprot.readStructBegin()
10521 
    while True:
10522 
      (fname, ftype, fid) = iprot.readFieldBegin()
10523 
      if ftype == TType.STOP:
10524 
        break
10525 
      if fid == 1:
10526 
        if ftype == TType.I64:
3064 chandransh 10527 
          self.orderId = iprot.readI64();
1135 chandransh 10528 
        else:
10529 
          iprot.skip(ftype)
10530 
      elif fid == 2:
3064 chandransh 10531 
        if ftype == TType.STRING:
10532 
          self.invoice_number = iprot.readString();
1135 chandransh 10533 
        else:
10534 
          iprot.skip(ftype)
3064 chandransh 10535 
      elif fid == 3:
4658 mandeep.dh 10536 
        if ftype == TType.STRING:
10537 
          self.serialNumber = iprot.readString();
3064 chandransh 10538 
        else:
10539 
          iprot.skip(ftype)
10540 
      elif fid == 4:
10541 
        if ftype == TType.STRING:
10542 
          self.itemNumber = iprot.readString();
10543 
        else:
10544 
          iprot.skip(ftype)
10545 
      elif fid == 5:
10546 
        if ftype == TType.STRING:
4283 anupam.sin 10547 
          self.billed_by = iprot.readString();
3064 chandransh 10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      elif fid == 6:
10551 
        if ftype == TType.I64:
4283 anupam.sin 10552 
          self.jacketNumber = iprot.readI64();
10553 
        else:
10554 
          iprot.skip(ftype)
10555 
      elif fid == 7:
10556 
        if ftype == TType.I64:
3064 chandransh 10557 
          self.billingType = iprot.readI64();
10558 
        else:
10559 
          iprot.skip(ftype)
4283 anupam.sin 10560 
      elif fid == 8:
10561 
        if ftype == TType.I64:
10562 
          self.vendorId = iprot.readI64();
10563 
        else:
10564 
          iprot.skip(ftype)
4763 rajveer 10565 
      elif fid == 9:
10566 
        if ftype == TType.BOOL:
10567 
          self.authorize = iprot.readBool();
10568 
        else:
10569 
          iprot.skip(ftype)
1246 chandransh 10570 
      else:
10571 
        iprot.skip(ftype)
10572 
      iprot.readFieldEnd()
10573 
    iprot.readStructEnd()
10574 
 
10575 
  def write(self, oprot):
10576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10578 
      return
4283 anupam.sin 10579 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10580 
    if self.orderId is not None:
3064 chandransh 10581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10582 
      oprot.writeI64(self.orderId)
1246 chandransh 10583 
      oprot.writeFieldEnd()
4283 anupam.sin 10584 
    if self.invoice_number is not None:
10585 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10586 
      oprot.writeString(self.invoice_number)
1246 chandransh 10587 
      oprot.writeFieldEnd()
4658 mandeep.dh 10588 
    if self.serialNumber is not None:
10589 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10590 
      oprot.writeString(self.serialNumber)
3064 chandransh 10591 
      oprot.writeFieldEnd()
3431 rajveer 10592 
    if self.itemNumber is not None:
3064 chandransh 10593 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10594 
      oprot.writeString(self.itemNumber)
10595 
      oprot.writeFieldEnd()
4283 anupam.sin 10596 
    if self.billed_by is not None:
10597 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10598 
      oprot.writeString(self.billed_by)
3064 chandransh 10599 
      oprot.writeFieldEnd()
4283 anupam.sin 10600 
    if self.jacketNumber is not None:
10601 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10602 
      oprot.writeI64(self.jacketNumber)
10603 
      oprot.writeFieldEnd()
3431 rajveer 10604 
    if self.billingType is not None:
4283 anupam.sin 10605 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10606 
      oprot.writeI64(self.billingType)
10607 
      oprot.writeFieldEnd()
4283 anupam.sin 10608 
    if self.vendorId is not None:
10609 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10610 
      oprot.writeI64(self.vendorId)
10611 
      oprot.writeFieldEnd()
4763 rajveer 10612 
    if self.authorize is not None:
10613 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10614 
      oprot.writeBool(self.authorize)
10615 
      oprot.writeFieldEnd()
1246 chandransh 10616 
    oprot.writeFieldStop()
10617 
    oprot.writeStructEnd()
10618 
 
3431 rajveer 10619 
  def validate(self):
10620 
    return
10621 
 
10622 
 
1246 chandransh 10623 
  def __repr__(self):
10624 
    L = ['%s=%r' % (key, value)
10625 
      for key, value in self.__dict__.iteritems()]
10626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10627 
 
10628 
  def __eq__(self, other):
10629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10630 
 
10631 
  def __ne__(self, other):
10632 
    return not (self == other)
10633 
 
4283 anupam.sin 10634 
class addBillingDetails_result:
1246 chandransh 10635 
  """
10636 
  Attributes:
3064 chandransh 10637 
   - success
1246 chandransh 10638 
   - ex
10639 
  """
10640 
 
10641 
  thrift_spec = (
3064 chandransh 10642 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10644 
  )
10645 
 
3064 chandransh 10646 
  def __init__(self, success=None, ex=None,):
10647 
    self.success = success
1246 chandransh 10648 
    self.ex = ex
10649 
 
10650 
  def read(self, iprot):
10651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10653 
      return
10654 
    iprot.readStructBegin()
10655 
    while True:
10656 
      (fname, ftype, fid) = iprot.readFieldBegin()
10657 
      if ftype == TType.STOP:
10658 
        break
3064 chandransh 10659 
      if fid == 0:
10660 
        if ftype == TType.BOOL:
10661 
          self.success = iprot.readBool();
10662 
        else:
10663 
          iprot.skip(ftype)
10664 
      elif fid == 1:
1246 chandransh 10665 
        if ftype == TType.STRUCT:
10666 
          self.ex = TransactionServiceException()
10667 
          self.ex.read(iprot)
10668 
        else:
10669 
          iprot.skip(ftype)
10670 
      else:
10671 
        iprot.skip(ftype)
10672 
      iprot.readFieldEnd()
10673 
    iprot.readStructEnd()
10674 
 
10675 
  def write(self, oprot):
10676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10678 
      return
4283 anupam.sin 10679 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10680 
    if self.success is not None:
3064 chandransh 10681 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10682 
      oprot.writeBool(self.success)
10683 
      oprot.writeFieldEnd()
3431 rajveer 10684 
    if self.ex is not None:
1246 chandransh 10685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10686 
      self.ex.write(oprot)
10687 
      oprot.writeFieldEnd()
10688 
    oprot.writeFieldStop()
10689 
    oprot.writeStructEnd()
10690 
 
3431 rajveer 10691 
  def validate(self):
10692 
    return
10693 
 
10694 
 
1246 chandransh 10695 
  def __repr__(self):
10696 
    L = ['%s=%r' % (key, value)
10697 
      for key, value in self.__dict__.iteritems()]
10698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10699 
 
10700 
  def __eq__(self, other):
10701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10702 
 
10703 
  def __ne__(self, other):
10704 
    return not (self == other)
10705 
 
4579 rajveer 10706 
class addInvoiceNumber_args:
10707 
  """
10708 
  Attributes:
10709 
   - orderId
10710 
   - invoiceNumber
4763 rajveer 10711 
   - color
4579 rajveer 10712 
  """
10713 
 
10714 
  thrift_spec = (
10715 
    None, # 0
10716 
    (1, TType.I64, 'orderId', None, None, ), # 1
10717 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10718 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10719 
  )
10720 
 
4763 rajveer 10721 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10722 
    self.orderId = orderId
10723 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10724 
    self.color = color
4579 rajveer 10725 
 
10726 
  def read(self, iprot):
10727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10729 
      return
10730 
    iprot.readStructBegin()
10731 
    while True:
10732 
      (fname, ftype, fid) = iprot.readFieldBegin()
10733 
      if ftype == TType.STOP:
10734 
        break
10735 
      if fid == 1:
10736 
        if ftype == TType.I64:
10737 
          self.orderId = iprot.readI64();
10738 
        else:
10739 
          iprot.skip(ftype)
10740 
      elif fid == 2:
10741 
        if ftype == TType.STRING:
10742 
          self.invoiceNumber = iprot.readString();
10743 
        else:
10744 
          iprot.skip(ftype)
4763 rajveer 10745 
      elif fid == 3:
10746 
        if ftype == TType.STRING:
10747 
          self.color = iprot.readString();
10748 
        else:
10749 
          iprot.skip(ftype)
4579 rajveer 10750 
      else:
10751 
        iprot.skip(ftype)
10752 
      iprot.readFieldEnd()
10753 
    iprot.readStructEnd()
10754 
 
10755 
  def write(self, oprot):
10756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10758 
      return
10759 
    oprot.writeStructBegin('addInvoiceNumber_args')
10760 
    if self.orderId is not None:
10761 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10762 
      oprot.writeI64(self.orderId)
10763 
      oprot.writeFieldEnd()
10764 
    if self.invoiceNumber is not None:
10765 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10766 
      oprot.writeString(self.invoiceNumber)
10767 
      oprot.writeFieldEnd()
4763 rajveer 10768 
    if self.color is not None:
10769 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10770 
      oprot.writeString(self.color)
10771 
      oprot.writeFieldEnd()
4579 rajveer 10772 
    oprot.writeFieldStop()
10773 
    oprot.writeStructEnd()
10774 
 
10775 
  def validate(self):
10776 
    return
10777 
 
10778 
 
10779 
  def __repr__(self):
10780 
    L = ['%s=%r' % (key, value)
10781 
      for key, value in self.__dict__.iteritems()]
10782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10783 
 
10784 
  def __eq__(self, other):
10785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10786 
 
10787 
  def __ne__(self, other):
10788 
    return not (self == other)
10789 
 
10790 
class addInvoiceNumber_result:
10791 
  """
10792 
  Attributes:
10793 
   - ex
10794 
  """
10795 
 
10796 
  thrift_spec = (
10797 
    None, # 0
10798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10799 
  )
10800 
 
10801 
  def __init__(self, ex=None,):
10802 
    self.ex = ex
10803 
 
10804 
  def read(self, iprot):
10805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10807 
      return
10808 
    iprot.readStructBegin()
10809 
    while True:
10810 
      (fname, ftype, fid) = iprot.readFieldBegin()
10811 
      if ftype == TType.STOP:
10812 
        break
10813 
      if fid == 1:
10814 
        if ftype == TType.STRUCT:
10815 
          self.ex = TransactionServiceException()
10816 
          self.ex.read(iprot)
10817 
        else:
10818 
          iprot.skip(ftype)
10819 
      else:
10820 
        iprot.skip(ftype)
10821 
      iprot.readFieldEnd()
10822 
    iprot.readStructEnd()
10823 
 
10824 
  def write(self, oprot):
10825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10827 
      return
10828 
    oprot.writeStructBegin('addInvoiceNumber_result')
10829 
    if self.ex is not None:
10830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10831 
      self.ex.write(oprot)
10832 
      oprot.writeFieldEnd()
10833 
    oprot.writeFieldStop()
10834 
    oprot.writeStructEnd()
10835 
 
10836 
  def validate(self):
10837 
    return
10838 
 
10839 
 
10840 
  def __repr__(self):
10841 
    L = ['%s=%r' % (key, value)
10842 
      for key, value in self.__dict__.iteritems()]
10843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10844 
 
10845 
  def __eq__(self, other):
10846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10847 
 
10848 
  def __ne__(self, other):
10849 
    return not (self == other)
10850 
 
3064 chandransh 10851 
class markOrdersAsManifested_args:
1408 ankur.sing 10852 
  """
10853 
  Attributes:
3064 chandransh 10854 
   - warehouseId
1408 ankur.sing 10855 
   - providerId
3064 chandransh 10856 
   - cod
1408 ankur.sing 10857 
  """
10858 
 
10859 
  thrift_spec = (
10860 
    None, # 0
3064 chandransh 10861 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10862 
    (2, TType.I64, 'providerId', None, None, ), # 2
10863 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10864 
  )
10865 
 
3064 chandransh 10866 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10867 
    self.warehouseId = warehouseId
1408 ankur.sing 10868 
    self.providerId = providerId
3064 chandransh 10869 
    self.cod = cod
1408 ankur.sing 10870 
 
10871 
  def read(self, iprot):
10872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10874 
      return
10875 
    iprot.readStructBegin()
10876 
    while True:
10877 
      (fname, ftype, fid) = iprot.readFieldBegin()
10878 
      if ftype == TType.STOP:
10879 
        break
10880 
      if fid == 1:
10881 
        if ftype == TType.I64:
3064 chandransh 10882 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10883 
        else:
10884 
          iprot.skip(ftype)
10885 
      elif fid == 2:
10886 
        if ftype == TType.I64:
3064 chandransh 10887 
          self.providerId = iprot.readI64();
1408 ankur.sing 10888 
        else:
10889 
          iprot.skip(ftype)
3064 chandransh 10890 
      elif fid == 3:
10891 
        if ftype == TType.BOOL:
10892 
          self.cod = iprot.readBool();
10893 
        else:
10894 
          iprot.skip(ftype)
1408 ankur.sing 10895 
      else:
10896 
        iprot.skip(ftype)
10897 
      iprot.readFieldEnd()
10898 
    iprot.readStructEnd()
10899 
 
10900 
  def write(self, oprot):
10901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10903 
      return
3064 chandransh 10904 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10905 
    if self.warehouseId is not None:
3064 chandransh 10906 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10907 
      oprot.writeI64(self.warehouseId)
10908 
      oprot.writeFieldEnd()
3431 rajveer 10909 
    if self.providerId is not None:
3064 chandransh 10910 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10911 
      oprot.writeI64(self.providerId)
10912 
      oprot.writeFieldEnd()
3431 rajveer 10913 
    if self.cod is not None:
3064 chandransh 10914 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10915 
      oprot.writeBool(self.cod)
1408 ankur.sing 10916 
      oprot.writeFieldEnd()
10917 
    oprot.writeFieldStop()
10918 
    oprot.writeStructEnd()
10919 
 
3431 rajveer 10920 
  def validate(self):
10921 
    return
10922 
 
10923 
 
1408 ankur.sing 10924 
  def __repr__(self):
10925 
    L = ['%s=%r' % (key, value)
10926 
      for key, value in self.__dict__.iteritems()]
10927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10928 
 
10929 
  def __eq__(self, other):
10930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10931 
 
10932 
  def __ne__(self, other):
10933 
    return not (self == other)
10934 
 
3064 chandransh 10935 
class markOrdersAsManifested_result:
1408 ankur.sing 10936 
  """
10937 
  Attributes:
10938 
   - success
3064 chandransh 10939 
   - ex
1408 ankur.sing 10940 
  """
10941 
 
10942 
  thrift_spec = (
3064 chandransh 10943 
    (0, TType.BOOL, 'success', None, None, ), # 0
10944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10945 
  )
10946 
 
3064 chandransh 10947 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10948 
    self.success = success
3064 chandransh 10949 
    self.ex = ex
1408 ankur.sing 10950 
 
10951 
  def read(self, iprot):
10952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10954 
      return
10955 
    iprot.readStructBegin()
10956 
    while True:
10957 
      (fname, ftype, fid) = iprot.readFieldBegin()
10958 
      if ftype == TType.STOP:
10959 
        break
10960 
      if fid == 0:
3064 chandransh 10961 
        if ftype == TType.BOOL:
10962 
          self.success = iprot.readBool();
1408 ankur.sing 10963 
        else:
10964 
          iprot.skip(ftype)
3064 chandransh 10965 
      elif fid == 1:
10966 
        if ftype == TType.STRUCT:
10967 
          self.ex = TransactionServiceException()
10968 
          self.ex.read(iprot)
10969 
        else:
10970 
          iprot.skip(ftype)
1408 ankur.sing 10971 
      else:
10972 
        iprot.skip(ftype)
10973 
      iprot.readFieldEnd()
10974 
    iprot.readStructEnd()
10975 
 
10976 
  def write(self, oprot):
10977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10979 
      return
3064 chandransh 10980 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10981 
    if self.success is not None:
3064 chandransh 10982 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10983 
      oprot.writeBool(self.success)
1408 ankur.sing 10984 
      oprot.writeFieldEnd()
3431 rajveer 10985 
    if self.ex is not None:
3064 chandransh 10986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10987 
      self.ex.write(oprot)
10988 
      oprot.writeFieldEnd()
1408 ankur.sing 10989 
    oprot.writeFieldStop()
10990 
    oprot.writeStructEnd()
10991 
 
3431 rajveer 10992 
  def validate(self):
10993 
    return
10994 
 
10995 
 
1408 ankur.sing 10996 
  def __repr__(self):
10997 
    L = ['%s=%r' % (key, value)
10998 
      for key, value in self.__dict__.iteritems()]
10999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11000 
 
11001 
  def __eq__(self, other):
11002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11003 
 
11004 
  def __ne__(self, other):
11005 
    return not (self == other)
11006 
 
4410 rajveer 11007 
class markOrdersAsShippedFromWarehouse_args:
11008 
  """
11009 
  Attributes:
11010 
   - warehouseId
11011 
   - providerId
11012 
   - cod
11013 
  """
11014 
 
11015 
  thrift_spec = (
11016 
    None, # 0
11017 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11018 
    (2, TType.I64, 'providerId', None, None, ), # 2
11019 
    (3, TType.BOOL, 'cod', None, None, ), # 3
11020 
  )
11021 
 
11022 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
11023 
    self.warehouseId = warehouseId
11024 
    self.providerId = providerId
11025 
    self.cod = cod
11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 1:
11037 
        if ftype == TType.I64:
11038 
          self.warehouseId = iprot.readI64();
11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 2:
11042 
        if ftype == TType.I64:
11043 
          self.providerId = iprot.readI64();
11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      elif fid == 3:
11047 
        if ftype == TType.BOOL:
11048 
          self.cod = iprot.readBool();
11049 
        else:
11050 
          iprot.skip(ftype)
11051 
      else:
11052 
        iprot.skip(ftype)
11053 
      iprot.readFieldEnd()
11054 
    iprot.readStructEnd()
11055 
 
11056 
  def write(self, oprot):
11057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11059 
      return
11060 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11061 
    if self.warehouseId is not None:
11062 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11063 
      oprot.writeI64(self.warehouseId)
11064 
      oprot.writeFieldEnd()
11065 
    if self.providerId is not None:
11066 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11067 
      oprot.writeI64(self.providerId)
11068 
      oprot.writeFieldEnd()
11069 
    if self.cod is not None:
11070 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11071 
      oprot.writeBool(self.cod)
11072 
      oprot.writeFieldEnd()
11073 
    oprot.writeFieldStop()
11074 
    oprot.writeStructEnd()
11075 
 
11076 
  def validate(self):
11077 
    return
11078 
 
11079 
 
11080 
  def __repr__(self):
11081 
    L = ['%s=%r' % (key, value)
11082 
      for key, value in self.__dict__.iteritems()]
11083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11084 
 
11085 
  def __eq__(self, other):
11086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11087 
 
11088 
  def __ne__(self, other):
11089 
    return not (self == other)
11090 
 
11091 
class markOrdersAsShippedFromWarehouse_result:
11092 
  """
11093 
  Attributes:
11094 
   - success
11095 
   - ex
11096 
  """
11097 
 
11098 
  thrift_spec = (
11099 
    (0, TType.BOOL, 'success', None, None, ), # 0
11100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11101 
  )
11102 
 
11103 
  def __init__(self, success=None, ex=None,):
11104 
    self.success = success
11105 
    self.ex = ex
11106 
 
11107 
  def read(self, iprot):
11108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11110 
      return
11111 
    iprot.readStructBegin()
11112 
    while True:
11113 
      (fname, ftype, fid) = iprot.readFieldBegin()
11114 
      if ftype == TType.STOP:
11115 
        break
11116 
      if fid == 0:
11117 
        if ftype == TType.BOOL:
11118 
          self.success = iprot.readBool();
11119 
        else:
11120 
          iprot.skip(ftype)
11121 
      elif fid == 1:
11122 
        if ftype == TType.STRUCT:
11123 
          self.ex = TransactionServiceException()
11124 
          self.ex.read(iprot)
11125 
        else:
11126 
          iprot.skip(ftype)
11127 
      else:
11128 
        iprot.skip(ftype)
11129 
      iprot.readFieldEnd()
11130 
    iprot.readStructEnd()
11131 
 
11132 
  def write(self, oprot):
11133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11135 
      return
11136 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11137 
    if self.success is not None:
11138 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11139 
      oprot.writeBool(self.success)
11140 
      oprot.writeFieldEnd()
11141 
    if self.ex is not None:
11142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11143 
      self.ex.write(oprot)
11144 
      oprot.writeFieldEnd()
11145 
    oprot.writeFieldStop()
11146 
    oprot.writeStructEnd()
11147 
 
11148 
  def validate(self):
11149 
    return
11150 
 
11151 
 
11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
3064 chandransh 11163 
class markOrdersAsPickedUp_args:
304 ashish 11164 
  """
11165 
  Attributes:
3064 chandransh 11166 
   - providerId
11167 
   - pickupDetails
304 ashish 11168 
  """
94 ashish 11169 
 
304 ashish 11170 
  thrift_spec = (
11171 
    None, # 0
3064 chandransh 11172 
    (1, TType.I64, 'providerId', None, None, ), # 1
11173 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11174 
  )
11175 
 
3064 chandransh 11176 
  def __init__(self, providerId=None, pickupDetails=None,):
11177 
    self.providerId = providerId
11178 
    self.pickupDetails = pickupDetails
304 ashish 11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      if fid == 1:
11190 
        if ftype == TType.I64:
3064 chandransh 11191 
          self.providerId = iprot.readI64();
304 ashish 11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      elif fid == 2:
3064 chandransh 11195 
        if ftype == TType.MAP:
11196 
          self.pickupDetails = {}
4133 chandransh 11197 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
11198 
          for _i144 in xrange(_size140):
11199 
            _key145 = iprot.readString();
11200 
            _val146 = iprot.readString();
11201 
            self.pickupDetails[_key145] = _val146
3064 chandransh 11202 
          iprot.readMapEnd()
304 ashish 11203 
        else:
11204 
          iprot.skip(ftype)
11205 
      else:
11206 
        iprot.skip(ftype)
11207 
      iprot.readFieldEnd()
11208 
    iprot.readStructEnd()
11209 
 
11210 
  def write(self, oprot):
11211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11213 
      return
3064 chandransh 11214 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11215 
    if self.providerId is not None:
3064 chandransh 11216 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11217 
      oprot.writeI64(self.providerId)
304 ashish 11218 
      oprot.writeFieldEnd()
3431 rajveer 11219 
    if self.pickupDetails is not None:
3064 chandransh 11220 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11221 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11222 
      for kiter147,viter148 in self.pickupDetails.items():
11223 
        oprot.writeString(kiter147)
11224 
        oprot.writeString(viter148)
3064 chandransh 11225 
      oprot.writeMapEnd()
304 ashish 11226 
      oprot.writeFieldEnd()
11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
3431 rajveer 11230 
  def validate(self):
11231 
    return
11232 
 
11233 
 
304 ashish 11234 
  def __repr__(self):
11235 
    L = ['%s=%r' % (key, value)
11236 
      for key, value in self.__dict__.iteritems()]
11237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11238 
 
11239 
  def __eq__(self, other):
11240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11241 
 
11242 
  def __ne__(self, other):
11243 
    return not (self == other)
11244 
 
3064 chandransh 11245 
class markOrdersAsPickedUp_result:
304 ashish 11246 
  """
11247 
  Attributes:
11248 
   - success
3064 chandransh 11249 
   - ex
304 ashish 11250 
  """
11251 
 
11252 
  thrift_spec = (
3064 chandransh 11253 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11254 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11255 
  )
11256 
 
3064 chandransh 11257 
  def __init__(self, success=None, ex=None,):
304 ashish 11258 
    self.success = success
3064 chandransh 11259 
    self.ex = ex
304 ashish 11260 
 
11261 
  def read(self, iprot):
11262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11264 
      return
11265 
    iprot.readStructBegin()
11266 
    while True:
11267 
      (fname, ftype, fid) = iprot.readFieldBegin()
11268 
      if ftype == TType.STOP:
11269 
        break
11270 
      if fid == 0:
11271 
        if ftype == TType.LIST:
11272 
          self.success = []
4133 chandransh 11273 
          (_etype152, _size149) = iprot.readListBegin()
11274 
          for _i153 in xrange(_size149):
11275 
            _elem154 = Order()
11276 
            _elem154.read(iprot)
11277 
            self.success.append(_elem154)
304 ashish 11278 
          iprot.readListEnd()
11279 
        else:
11280 
          iprot.skip(ftype)
3064 chandransh 11281 
      elif fid == 1:
11282 
        if ftype == TType.STRUCT:
11283 
          self.ex = TransactionServiceException()
11284 
          self.ex.read(iprot)
11285 
        else:
11286 
          iprot.skip(ftype)
304 ashish 11287 
      else:
11288 
        iprot.skip(ftype)
11289 
      iprot.readFieldEnd()
11290 
    iprot.readStructEnd()
11291 
 
11292 
  def write(self, oprot):
11293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11295 
      return
3064 chandransh 11296 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11297 
    if self.success is not None:
304 ashish 11298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11299 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11300 
      for iter155 in self.success:
11301 
        iter155.write(oprot)
304 ashish 11302 
      oprot.writeListEnd()
11303 
      oprot.writeFieldEnd()
3431 rajveer 11304 
    if self.ex is not None:
3064 chandransh 11305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11306 
      self.ex.write(oprot)
11307 
      oprot.writeFieldEnd()
304 ashish 11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
304 ashish 11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
3064 chandransh 11326 
class markOrdersAsDelivered_args:
304 ashish 11327 
  """
11328 
  Attributes:
3064 chandransh 11329 
   - providerId
11330 
   - deliveredOrders
304 ashish 11331 
  """
11332 
 
11333 
  thrift_spec = (
11334 
    None, # 0
3064 chandransh 11335 
    (1, TType.I64, 'providerId', None, None, ), # 1
11336 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11337 
  )
11338 
 
3064 chandransh 11339 
  def __init__(self, providerId=None, deliveredOrders=None,):
11340 
    self.providerId = providerId
11341 
    self.deliveredOrders = deliveredOrders
304 ashish 11342 
 
11343 
  def read(self, iprot):
11344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11346 
      return
11347 
    iprot.readStructBegin()
11348 
    while True:
11349 
      (fname, ftype, fid) = iprot.readFieldBegin()
11350 
      if ftype == TType.STOP:
11351 
        break
11352 
      if fid == 1:
11353 
        if ftype == TType.I64:
3064 chandransh 11354 
          self.providerId = iprot.readI64();
304 ashish 11355 
        else:
11356 
          iprot.skip(ftype)
11357 
      elif fid == 2:
3064 chandransh 11358 
        if ftype == TType.MAP:
11359 
          self.deliveredOrders = {}
4133 chandransh 11360 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11361 
          for _i160 in xrange(_size156):
11362 
            _key161 = iprot.readString();
11363 
            _val162 = iprot.readString();
11364 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11365 
          iprot.readMapEnd()
304 ashish 11366 
        else:
11367 
          iprot.skip(ftype)
11368 
      else:
11369 
        iprot.skip(ftype)
11370 
      iprot.readFieldEnd()
11371 
    iprot.readStructEnd()
11372 
 
11373 
  def write(self, oprot):
11374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11376 
      return
3064 chandransh 11377 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11378 
    if self.providerId is not None:
3064 chandransh 11379 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11380 
      oprot.writeI64(self.providerId)
304 ashish 11381 
      oprot.writeFieldEnd()
3431 rajveer 11382 
    if self.deliveredOrders is not None:
3064 chandransh 11383 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11384 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11385 
      for kiter163,viter164 in self.deliveredOrders.items():
11386 
        oprot.writeString(kiter163)
11387 
        oprot.writeString(viter164)
3064 chandransh 11388 
      oprot.writeMapEnd()
304 ashish 11389 
      oprot.writeFieldEnd()
11390 
    oprot.writeFieldStop()
11391 
    oprot.writeStructEnd()
11392 
 
3431 rajveer 11393 
  def validate(self):
11394 
    return
11395 
 
11396 
 
304 ashish 11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
3064 chandransh 11408 
class markOrdersAsDelivered_result:
11409 
  """
11410 
  Attributes:
11411 
   - ex
11412 
  """
304 ashish 11413 
 
11414 
  thrift_spec = (
3064 chandransh 11415 
    None, # 0
11416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11417 
  )
11418 
 
3064 chandransh 11419 
  def __init__(self, ex=None,):
11420 
    self.ex = ex
304 ashish 11421 
 
1596 ankur.sing 11422 
  def read(self, iprot):
11423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11425 
      return
11426 
    iprot.readStructBegin()
11427 
    while True:
11428 
      (fname, ftype, fid) = iprot.readFieldBegin()
11429 
      if ftype == TType.STOP:
11430 
        break
3064 chandransh 11431 
      if fid == 1:
11432 
        if ftype == TType.STRUCT:
11433 
          self.ex = TransactionServiceException()
11434 
          self.ex.read(iprot)
11435 
        else:
11436 
          iprot.skip(ftype)
1596 ankur.sing 11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
3064 chandransh 11446 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11447 
    if self.ex is not None:
3064 chandransh 11448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11449 
      self.ex.write(oprot)
11450 
      oprot.writeFieldEnd()
1596 ankur.sing 11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
3431 rajveer 11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
1596 ankur.sing 11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
3064 chandransh 11469 
class markOrdersAsFailed_args:
1596 ankur.sing 11470 
  """
11471 
  Attributes:
3064 chandransh 11472 
   - providerId
11473 
   - returnedOrders
1596 ankur.sing 11474 
  """
11475 
 
11476 
  thrift_spec = (
3064 chandransh 11477 
    None, # 0
11478 
    (1, TType.I64, 'providerId', None, None, ), # 1
11479 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11480 
  )
11481 
 
3064 chandransh 11482 
  def __init__(self, providerId=None, returnedOrders=None,):
11483 
    self.providerId = providerId
11484 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11485 
 
11486 
  def read(self, iprot):
11487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11489 
      return
11490 
    iprot.readStructBegin()
11491 
    while True:
11492 
      (fname, ftype, fid) = iprot.readFieldBegin()
11493 
      if ftype == TType.STOP:
11494 
        break
3064 chandransh 11495 
      if fid == 1:
1596 ankur.sing 11496 
        if ftype == TType.I64:
3064 chandransh 11497 
          self.providerId = iprot.readI64();
1596 ankur.sing 11498 
        else:
11499 
          iprot.skip(ftype)
3064 chandransh 11500 
      elif fid == 2:
11501 
        if ftype == TType.MAP:
11502 
          self.returnedOrders = {}
4133 chandransh 11503 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11504 
          for _i169 in xrange(_size165):
11505 
            _key170 = iprot.readString();
11506 
            _val171 = iprot.readString();
11507 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11508 
          iprot.readMapEnd()
11509 
        else:
11510 
          iprot.skip(ftype)
1596 ankur.sing 11511 
      else:
11512 
        iprot.skip(ftype)
11513 
      iprot.readFieldEnd()
11514 
    iprot.readStructEnd()
11515 
 
11516 
  def write(self, oprot):
11517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11519 
      return
3064 chandransh 11520 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11521 
    if self.providerId is not None:
3064 chandransh 11522 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11523 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11524 
      oprot.writeFieldEnd()
3431 rajveer 11525 
    if self.returnedOrders is not None:
3064 chandransh 11526 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11527 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11528 
      for kiter172,viter173 in self.returnedOrders.items():
11529 
        oprot.writeString(kiter172)
11530 
        oprot.writeString(viter173)
3064 chandransh 11531 
      oprot.writeMapEnd()
11532 
      oprot.writeFieldEnd()
1596 ankur.sing 11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
3431 rajveer 11536 
  def validate(self):
11537 
    return
11538 
 
11539 
 
1596 ankur.sing 11540 
  def __repr__(self):
11541 
    L = ['%s=%r' % (key, value)
11542 
      for key, value in self.__dict__.iteritems()]
11543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11544 
 
11545 
  def __eq__(self, other):
11546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11547 
 
11548 
  def __ne__(self, other):
11549 
    return not (self == other)
11550 
 
3064 chandransh 11551 
class markOrdersAsFailed_result:
11552 
  """
11553 
  Attributes:
11554 
   - ex
11555 
  """
1596 ankur.sing 11556 
 
1627 ankur.sing 11557 
  thrift_spec = (
3064 chandransh 11558 
    None, # 0
11559 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11560 
  )
11561 
 
3064 chandransh 11562 
  def __init__(self, ex=None,):
11563 
    self.ex = ex
11564 
 
1627 ankur.sing 11565 
  def read(self, iprot):
11566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11568 
      return
11569 
    iprot.readStructBegin()
11570 
    while True:
11571 
      (fname, ftype, fid) = iprot.readFieldBegin()
11572 
      if ftype == TType.STOP:
11573 
        break
3064 chandransh 11574 
      if fid == 1:
11575 
        if ftype == TType.STRUCT:
11576 
          self.ex = TransactionServiceException()
11577 
          self.ex.read(iprot)
11578 
        else:
11579 
          iprot.skip(ftype)
1627 ankur.sing 11580 
      else:
11581 
        iprot.skip(ftype)
11582 
      iprot.readFieldEnd()
11583 
    iprot.readStructEnd()
11584 
 
11585 
  def write(self, oprot):
11586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11588 
      return
3064 chandransh 11589 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11590 
    if self.ex is not None:
3064 chandransh 11591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11592 
      self.ex.write(oprot)
11593 
      oprot.writeFieldEnd()
1627 ankur.sing 11594 
    oprot.writeFieldStop()
11595 
    oprot.writeStructEnd()
11596 
 
3431 rajveer 11597 
  def validate(self):
11598 
    return
11599 
 
11600 
 
1627 ankur.sing 11601 
  def __repr__(self):
11602 
    L = ['%s=%r' % (key, value)
11603 
      for key, value in self.__dict__.iteritems()]
11604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11605 
 
11606 
  def __eq__(self, other):
11607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11608 
 
11609 
  def __ne__(self, other):
11610 
    return not (self == other)
11611 
 
3064 chandransh 11612 
class updateNonDeliveryReason_args:
1627 ankur.sing 11613 
  """
11614 
  Attributes:
3064 chandransh 11615 
   - providerId
11616 
   - undeliveredOrders
1627 ankur.sing 11617 
  """
11618 
 
11619 
  thrift_spec = (
3064 chandransh 11620 
    None, # 0
11621 
    (1, TType.I64, 'providerId', None, None, ), # 1
11622 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11623 
  )
11624 
 
3064 chandransh 11625 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11626 
    self.providerId = providerId
11627 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11628 
 
11629 
  def read(self, iprot):
11630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11632 
      return
11633 
    iprot.readStructBegin()
11634 
    while True:
11635 
      (fname, ftype, fid) = iprot.readFieldBegin()
11636 
      if ftype == TType.STOP:
11637 
        break
3064 chandransh 11638 
      if fid == 1:
1627 ankur.sing 11639 
        if ftype == TType.I64:
3064 chandransh 11640 
          self.providerId = iprot.readI64();
1627 ankur.sing 11641 
        else:
11642 
          iprot.skip(ftype)
3064 chandransh 11643 
      elif fid == 2:
11644 
        if ftype == TType.MAP:
11645 
          self.undeliveredOrders = {}
4133 chandransh 11646 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11647 
          for _i178 in xrange(_size174):
11648 
            _key179 = iprot.readString();
11649 
            _val180 = iprot.readString();
11650 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11651 
          iprot.readMapEnd()
11652 
        else:
11653 
          iprot.skip(ftype)
1627 ankur.sing 11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
3064 chandransh 11663 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11664 
    if self.providerId is not None:
3064 chandransh 11665 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11666 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11667 
      oprot.writeFieldEnd()
3431 rajveer 11668 
    if self.undeliveredOrders is not None:
3064 chandransh 11669 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11670 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11671 
      for kiter181,viter182 in self.undeliveredOrders.items():
11672 
        oprot.writeString(kiter181)
11673 
        oprot.writeString(viter182)
3064 chandransh 11674 
      oprot.writeMapEnd()
11675 
      oprot.writeFieldEnd()
1627 ankur.sing 11676 
    oprot.writeFieldStop()
11677 
    oprot.writeStructEnd()
11678 
 
3431 rajveer 11679 
  def validate(self):
11680 
    return
11681 
 
11682 
 
1627 ankur.sing 11683 
  def __repr__(self):
11684 
    L = ['%s=%r' % (key, value)
11685 
      for key, value in self.__dict__.iteritems()]
11686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11687 
 
11688 
  def __eq__(self, other):
11689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11690 
 
11691 
  def __ne__(self, other):
11692 
    return not (self == other)
11693 
 
3064 chandransh 11694 
class updateNonDeliveryReason_result:
1627 ankur.sing 11695 
  """
11696 
  Attributes:
4581 phani.kuma 11697 
   - success
3064 chandransh 11698 
   - ex
1627 ankur.sing 11699 
  """
11700 
 
11701 
  thrift_spec = (
4581 phani.kuma 11702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11704 
  )
11705 
 
4581 phani.kuma 11706 
  def __init__(self, success=None, ex=None,):
11707 
    self.success = success
3064 chandransh 11708 
    self.ex = ex
1627 ankur.sing 11709 
 
11710 
  def read(self, iprot):
11711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11713 
      return
11714 
    iprot.readStructBegin()
11715 
    while True:
11716 
      (fname, ftype, fid) = iprot.readFieldBegin()
11717 
      if ftype == TType.STOP:
11718 
        break
4581 phani.kuma 11719 
      if fid == 0:
11720 
        if ftype == TType.LIST:
11721 
          self.success = []
11722 
          (_etype186, _size183) = iprot.readListBegin()
11723 
          for _i187 in xrange(_size183):
11724 
            _elem188 = Order()
11725 
            _elem188.read(iprot)
11726 
            self.success.append(_elem188)
11727 
          iprot.readListEnd()
11728 
        else:
11729 
          iprot.skip(ftype)
11730 
      elif fid == 1:
3064 chandransh 11731 
        if ftype == TType.STRUCT:
11732 
          self.ex = TransactionServiceException()
11733 
          self.ex.read(iprot)
1627 ankur.sing 11734 
        else:
11735 
          iprot.skip(ftype)
11736 
      else:
11737 
        iprot.skip(ftype)
11738 
      iprot.readFieldEnd()
11739 
    iprot.readStructEnd()
11740 
 
11741 
  def write(self, oprot):
11742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11744 
      return
3064 chandransh 11745 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11746 
    if self.success is not None:
11747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11749 
      for iter189 in self.success:
11750 
        iter189.write(oprot)
11751 
      oprot.writeListEnd()
11752 
      oprot.writeFieldEnd()
3431 rajveer 11753 
    if self.ex is not None:
3064 chandransh 11754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11755 
      self.ex.write(oprot)
1627 ankur.sing 11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
1627 ankur.sing 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
3064 chandransh 11775 
class getUndeliveredOrders_args:
1886 ankur.sing 11776 
  """
11777 
  Attributes:
3064 chandransh 11778 
   - providerId
11779 
   - warehouseId
1886 ankur.sing 11780 
  """
1627 ankur.sing 11781 
 
1886 ankur.sing 11782 
  thrift_spec = (
11783 
    None, # 0
3064 chandransh 11784 
    (1, TType.I64, 'providerId', None, None, ), # 1
11785 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11786 
  )
11787 
 
3064 chandransh 11788 
  def __init__(self, providerId=None, warehouseId=None,):
11789 
    self.providerId = providerId
11790 
    self.warehouseId = warehouseId
1886 ankur.sing 11791 
 
11792 
  def read(self, iprot):
11793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11795 
      return
11796 
    iprot.readStructBegin()
11797 
    while True:
11798 
      (fname, ftype, fid) = iprot.readFieldBegin()
11799 
      if ftype == TType.STOP:
11800 
        break
11801 
      if fid == 1:
11802 
        if ftype == TType.I64:
3064 chandransh 11803 
          self.providerId = iprot.readI64();
1886 ankur.sing 11804 
        else:
11805 
          iprot.skip(ftype)
3064 chandransh 11806 
      elif fid == 2:
11807 
        if ftype == TType.I64:
11808 
          self.warehouseId = iprot.readI64();
11809 
        else:
11810 
          iprot.skip(ftype)
1886 ankur.sing 11811 
      else:
11812 
        iprot.skip(ftype)
11813 
      iprot.readFieldEnd()
11814 
    iprot.readStructEnd()
11815 
 
11816 
  def write(self, oprot):
11817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11819 
      return
3064 chandransh 11820 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11821 
    if self.providerId is not None:
3064 chandransh 11822 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11823 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11824 
      oprot.writeFieldEnd()
3431 rajveer 11825 
    if self.warehouseId is not None:
3064 chandransh 11826 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11827 
      oprot.writeI64(self.warehouseId)
11828 
      oprot.writeFieldEnd()
1886 ankur.sing 11829 
    oprot.writeFieldStop()
11830 
    oprot.writeStructEnd()
11831 
 
3431 rajveer 11832 
  def validate(self):
11833 
    return
11834 
 
11835 
 
1886 ankur.sing 11836 
  def __repr__(self):
11837 
    L = ['%s=%r' % (key, value)
11838 
      for key, value in self.__dict__.iteritems()]
11839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11840 
 
11841 
  def __eq__(self, other):
11842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11843 
 
11844 
  def __ne__(self, other):
11845 
    return not (self == other)
11846 
 
3064 chandransh 11847 
class getUndeliveredOrders_result:
1886 ankur.sing 11848 
  """
11849 
  Attributes:
11850 
   - success
11851 
  """
11852 
 
11853 
  thrift_spec = (
11854 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11855 
  )
11856 
 
11857 
  def __init__(self, success=None,):
11858 
    self.success = success
11859 
 
11860 
  def read(self, iprot):
11861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11863 
      return
11864 
    iprot.readStructBegin()
11865 
    while True:
11866 
      (fname, ftype, fid) = iprot.readFieldBegin()
11867 
      if ftype == TType.STOP:
11868 
        break
11869 
      if fid == 0:
11870 
        if ftype == TType.LIST:
11871 
          self.success = []
4581 phani.kuma 11872 
          (_etype193, _size190) = iprot.readListBegin()
11873 
          for _i194 in xrange(_size190):
11874 
            _elem195 = Order()
11875 
            _elem195.read(iprot)
11876 
            self.success.append(_elem195)
1886 ankur.sing 11877 
          iprot.readListEnd()
11878 
        else:
11879 
          iprot.skip(ftype)
11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
3064 chandransh 11889 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11890 
    if self.success is not None:
1886 ankur.sing 11891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11893 
      for iter196 in self.success:
11894 
        iter196.write(oprot)
1886 ankur.sing 11895 
      oprot.writeListEnd()
11896 
      oprot.writeFieldEnd()
11897 
    oprot.writeFieldStop()
11898 
    oprot.writeStructEnd()
11899 
 
3431 rajveer 11900 
  def validate(self):
11901 
    return
11902 
 
11903 
 
1886 ankur.sing 11904 
  def __repr__(self):
11905 
    L = ['%s=%r' % (key, value)
11906 
      for key, value in self.__dict__.iteritems()]
11907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11908 
 
11909 
  def __eq__(self, other):
11910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11911 
 
11912 
  def __ne__(self, other):
11913 
    return not (self == other)
11914 
 
4783 phani.kuma 11915 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
11916 
 
11917 
  thrift_spec = (
11918 
  )
11919 
 
11920 
  def read(self, iprot):
11921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11923 
      return
11924 
    iprot.readStructBegin()
11925 
    while True:
11926 
      (fname, ftype, fid) = iprot.readFieldBegin()
11927 
      if ftype == TType.STOP:
11928 
        break
11929 
      else:
11930 
        iprot.skip(ftype)
11931 
      iprot.readFieldEnd()
11932 
    iprot.readStructEnd()
11933 
 
11934 
  def write(self, oprot):
11935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11937 
      return
11938 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
11939 
    oprot.writeFieldStop()
11940 
    oprot.writeStructEnd()
11941 
 
11942 
  def validate(self):
11943 
    return
11944 
 
11945 
 
11946 
  def __repr__(self):
11947 
    L = ['%s=%r' % (key, value)
11948 
      for key, value in self.__dict__.iteritems()]
11949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11950 
 
11951 
  def __eq__(self, other):
11952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11953 
 
11954 
  def __ne__(self, other):
11955 
    return not (self == other)
11956 
 
11957 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
11958 
  """
11959 
  Attributes:
11960 
   - success
11961 
  """
11962 
 
11963 
  thrift_spec = (
11964 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11965 
  )
11966 
 
11967 
  def __init__(self, success=None,):
11968 
    self.success = success
11969 
 
11970 
  def read(self, iprot):
11971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11973 
      return
11974 
    iprot.readStructBegin()
11975 
    while True:
11976 
      (fname, ftype, fid) = iprot.readFieldBegin()
11977 
      if ftype == TType.STOP:
11978 
        break
11979 
      if fid == 0:
11980 
        if ftype == TType.LIST:
11981 
          self.success = []
11982 
          (_etype200, _size197) = iprot.readListBegin()
11983 
          for _i201 in xrange(_size197):
11984 
            _elem202 = Order()
11985 
            _elem202.read(iprot)
11986 
            self.success.append(_elem202)
11987 
          iprot.readListEnd()
11988 
        else:
11989 
          iprot.skip(ftype)
11990 
      else:
11991 
        iprot.skip(ftype)
11992 
      iprot.readFieldEnd()
11993 
    iprot.readStructEnd()
11994 
 
11995 
  def write(self, oprot):
11996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11998 
      return
11999 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
12000 
    if self.success is not None:
12001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12003 
      for iter203 in self.success:
12004 
        iter203.write(oprot)
12005 
      oprot.writeListEnd()
12006 
      oprot.writeFieldEnd()
12007 
    oprot.writeFieldStop()
12008 
    oprot.writeStructEnd()
12009 
 
12010 
  def validate(self):
12011 
    return
12012 
 
12013 
 
12014 
  def __repr__(self):
12015 
    L = ['%s=%r' % (key, value)
12016 
      for key, value in self.__dict__.iteritems()]
12017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12018 
 
12019 
  def __eq__(self, other):
12020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12021 
 
12022 
  def __ne__(self, other):
12023 
    return not (self == other)
12024 
 
2536 chandransh 12025 
class toggleDOAFlag_args:
12026 
  """
12027 
  Attributes:
12028 
   - orderId
12029 
  """
1886 ankur.sing 12030 
 
2536 chandransh 12031 
  thrift_spec = (
12032 
    None, # 0
12033 
    (1, TType.I64, 'orderId', None, None, ), # 1
12034 
  )
12035 
 
12036 
  def __init__(self, orderId=None,):
12037 
    self.orderId = orderId
12038 
 
12039 
  def read(self, iprot):
12040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12042 
      return
12043 
    iprot.readStructBegin()
12044 
    while True:
12045 
      (fname, ftype, fid) = iprot.readFieldBegin()
12046 
      if ftype == TType.STOP:
12047 
        break
12048 
      if fid == 1:
12049 
        if ftype == TType.I64:
12050 
          self.orderId = iprot.readI64();
12051 
        else:
12052 
          iprot.skip(ftype)
12053 
      else:
12054 
        iprot.skip(ftype)
12055 
      iprot.readFieldEnd()
12056 
    iprot.readStructEnd()
12057 
 
12058 
  def write(self, oprot):
12059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12061 
      return
12062 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 12063 
    if self.orderId is not None:
2536 chandransh 12064 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12065 
      oprot.writeI64(self.orderId)
12066 
      oprot.writeFieldEnd()
12067 
    oprot.writeFieldStop()
12068 
    oprot.writeStructEnd()
12069 
 
3431 rajveer 12070 
  def validate(self):
12071 
    return
12072 
 
12073 
 
2536 chandransh 12074 
  def __repr__(self):
12075 
    L = ['%s=%r' % (key, value)
12076 
      for key, value in self.__dict__.iteritems()]
12077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12078 
 
12079 
  def __eq__(self, other):
12080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12081 
 
12082 
  def __ne__(self, other):
12083 
    return not (self == other)
12084 
 
12085 
class toggleDOAFlag_result:
12086 
  """
12087 
  Attributes:
12088 
   - success
12089 
   - ex
12090 
  """
12091 
 
12092 
  thrift_spec = (
12093 
    (0, TType.BOOL, 'success', None, None, ), # 0
12094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12095 
  )
12096 
 
12097 
  def __init__(self, success=None, ex=None,):
12098 
    self.success = success
12099 
    self.ex = ex
12100 
 
12101 
  def read(self, iprot):
12102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12104 
      return
12105 
    iprot.readStructBegin()
12106 
    while True:
12107 
      (fname, ftype, fid) = iprot.readFieldBegin()
12108 
      if ftype == TType.STOP:
12109 
        break
12110 
      if fid == 0:
12111 
        if ftype == TType.BOOL:
12112 
          self.success = iprot.readBool();
12113 
        else:
12114 
          iprot.skip(ftype)
12115 
      elif fid == 1:
12116 
        if ftype == TType.STRUCT:
12117 
          self.ex = TransactionServiceException()
12118 
          self.ex.read(iprot)
12119 
        else:
12120 
          iprot.skip(ftype)
12121 
      else:
12122 
        iprot.skip(ftype)
12123 
      iprot.readFieldEnd()
12124 
    iprot.readStructEnd()
12125 
 
12126 
  def write(self, oprot):
12127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12129 
      return
12130 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 12131 
    if self.success is not None:
2536 chandransh 12132 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12133 
      oprot.writeBool(self.success)
12134 
      oprot.writeFieldEnd()
3431 rajveer 12135 
    if self.ex is not None:
2536 chandransh 12136 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12137 
      self.ex.write(oprot)
12138 
      oprot.writeFieldEnd()
12139 
    oprot.writeFieldStop()
12140 
    oprot.writeStructEnd()
12141 
 
3431 rajveer 12142 
  def validate(self):
12143 
    return
12144 
 
12145 
 
2536 chandransh 12146 
  def __repr__(self):
12147 
    L = ['%s=%r' % (key, value)
12148 
      for key, value in self.__dict__.iteritems()]
12149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12150 
 
12151 
  def __eq__(self, other):
12152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12153 
 
12154 
  def __ne__(self, other):
12155 
    return not (self == other)
12156 
 
4712 rajveer 12157 
class markOrderAsDelivered_args:
12158 
  """
12159 
  Attributes:
12160 
   - orderId
12161 
   - deliveryTimestamp
12162 
   - receiver
12163 
  """
12164 
 
12165 
  thrift_spec = None
12166 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12167 
    self.orderId = orderId
12168 
    self.deliveryTimestamp = deliveryTimestamp
12169 
    self.receiver = receiver
12170 
 
12171 
  def read(self, iprot):
12172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12174 
      return
12175 
    iprot.readStructBegin()
12176 
    while True:
12177 
      (fname, ftype, fid) = iprot.readFieldBegin()
12178 
      if ftype == TType.STOP:
12179 
        break
12180 
      if fid == 1:
12181 
        if ftype == TType.I64:
12182 
          self.orderId = iprot.readI64();
12183 
        else:
12184 
          iprot.skip(ftype)
12185 
      elif fid == 2:
12186 
        if ftype == TType.I64:
12187 
          self.deliveryTimestamp = iprot.readI64();
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      elif fid == -1:
12191 
        if ftype == TType.STRING:
12192 
          self.receiver = iprot.readString();
12193 
        else:
12194 
          iprot.skip(ftype)
12195 
      else:
12196 
        iprot.skip(ftype)
12197 
      iprot.readFieldEnd()
12198 
    iprot.readStructEnd()
12199 
 
12200 
  def write(self, oprot):
12201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12203 
      return
12204 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12205 
    if self.receiver is not None:
12206 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12207 
      oprot.writeString(self.receiver)
12208 
      oprot.writeFieldEnd()
12209 
    if self.orderId is not None:
12210 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12211 
      oprot.writeI64(self.orderId)
12212 
      oprot.writeFieldEnd()
12213 
    if self.deliveryTimestamp is not None:
12214 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12215 
      oprot.writeI64(self.deliveryTimestamp)
12216 
      oprot.writeFieldEnd()
12217 
    oprot.writeFieldStop()
12218 
    oprot.writeStructEnd()
12219 
 
12220 
  def validate(self):
12221 
    return
12222 
 
12223 
 
12224 
  def __repr__(self):
12225 
    L = ['%s=%r' % (key, value)
12226 
      for key, value in self.__dict__.iteritems()]
12227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12228 
 
12229 
  def __eq__(self, other):
12230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12231 
 
12232 
  def __ne__(self, other):
12233 
    return not (self == other)
12234 
 
12235 
class markOrderAsDelivered_result:
12236 
  """
12237 
  Attributes:
12238 
   - ex
12239 
  """
12240 
 
12241 
  thrift_spec = (
12242 
    None, # 0
12243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12244 
  )
12245 
 
12246 
  def __init__(self, ex=None,):
12247 
    self.ex = ex
12248 
 
12249 
  def read(self, iprot):
12250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12252 
      return
12253 
    iprot.readStructBegin()
12254 
    while True:
12255 
      (fname, ftype, fid) = iprot.readFieldBegin()
12256 
      if ftype == TType.STOP:
12257 
        break
12258 
      if fid == 1:
12259 
        if ftype == TType.STRUCT:
12260 
          self.ex = TransactionServiceException()
12261 
          self.ex.read(iprot)
12262 
        else:
12263 
          iprot.skip(ftype)
12264 
      else:
12265 
        iprot.skip(ftype)
12266 
      iprot.readFieldEnd()
12267 
    iprot.readStructEnd()
12268 
 
12269 
  def write(self, oprot):
12270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12272 
      return
12273 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12274 
    if self.ex is not None:
12275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12276 
      self.ex.write(oprot)
12277 
      oprot.writeFieldEnd()
12278 
    oprot.writeFieldStop()
12279 
    oprot.writeStructEnd()
12280 
 
12281 
  def validate(self):
12282 
    return
12283 
 
12284 
 
12285 
  def __repr__(self):
12286 
    L = ['%s=%r' % (key, value)
12287 
      for key, value in self.__dict__.iteritems()]
12288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12289 
 
12290 
  def __eq__(self, other):
12291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12292 
 
12293 
  def __ne__(self, other):
12294 
    return not (self == other)
12295 
 
4454 rajveer 12296 
class markOrderDoaRequestReceived_args:
12297 
  """
12298 
  Attributes:
12299 
   - orderId
12300 
  """
12301 
 
12302 
  thrift_spec = (
12303 
    None, # 0
12304 
    (1, TType.I64, 'orderId', None, None, ), # 1
12305 
  )
12306 
 
12307 
  def __init__(self, orderId=None,):
12308 
    self.orderId = orderId
12309 
 
12310 
  def read(self, iprot):
12311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12313 
      return
12314 
    iprot.readStructBegin()
12315 
    while True:
12316 
      (fname, ftype, fid) = iprot.readFieldBegin()
12317 
      if ftype == TType.STOP:
12318 
        break
12319 
      if fid == 1:
12320 
        if ftype == TType.I64:
12321 
          self.orderId = iprot.readI64();
12322 
        else:
12323 
          iprot.skip(ftype)
12324 
      else:
12325 
        iprot.skip(ftype)
12326 
      iprot.readFieldEnd()
12327 
    iprot.readStructEnd()
12328 
 
12329 
  def write(self, oprot):
12330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12332 
      return
12333 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12334 
    if self.orderId is not None:
12335 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12336 
      oprot.writeI64(self.orderId)
12337 
      oprot.writeFieldEnd()
12338 
    oprot.writeFieldStop()
12339 
    oprot.writeStructEnd()
12340 
 
12341 
  def validate(self):
12342 
    return
12343 
 
12344 
 
12345 
  def __repr__(self):
12346 
    L = ['%s=%r' % (key, value)
12347 
      for key, value in self.__dict__.iteritems()]
12348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12349 
 
12350 
  def __eq__(self, other):
12351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12352 
 
12353 
  def __ne__(self, other):
12354 
    return not (self == other)
12355 
 
12356 
class markOrderDoaRequestReceived_result:
12357 
  """
12358 
  Attributes:
12359 
   - success
12360 
   - ex
12361 
  """
12362 
 
12363 
  thrift_spec = (
12364 
    (0, TType.BOOL, 'success', None, None, ), # 0
12365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12366 
  )
12367 
 
12368 
  def __init__(self, success=None, ex=None,):
12369 
    self.success = success
12370 
    self.ex = ex
12371 
 
12372 
  def read(self, iprot):
12373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12375 
      return
12376 
    iprot.readStructBegin()
12377 
    while True:
12378 
      (fname, ftype, fid) = iprot.readFieldBegin()
12379 
      if ftype == TType.STOP:
12380 
        break
12381 
      if fid == 0:
12382 
        if ftype == TType.BOOL:
12383 
          self.success = iprot.readBool();
12384 
        else:
12385 
          iprot.skip(ftype)
12386 
      elif fid == 1:
12387 
        if ftype == TType.STRUCT:
12388 
          self.ex = TransactionServiceException()
12389 
          self.ex.read(iprot)
12390 
        else:
12391 
          iprot.skip(ftype)
12392 
      else:
12393 
        iprot.skip(ftype)
12394 
      iprot.readFieldEnd()
12395 
    iprot.readStructEnd()
12396 
 
12397 
  def write(self, oprot):
12398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12400 
      return
12401 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12402 
    if self.success is not None:
12403 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12404 
      oprot.writeBool(self.success)
12405 
      oprot.writeFieldEnd()
12406 
    if self.ex is not None:
12407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12408 
      self.ex.write(oprot)
12409 
      oprot.writeFieldEnd()
12410 
    oprot.writeFieldStop()
12411 
    oprot.writeStructEnd()
12412 
 
12413 
  def validate(self):
12414 
    return
12415 
 
12416 
 
12417 
  def __repr__(self):
12418 
    L = ['%s=%r' % (key, value)
12419 
      for key, value in self.__dict__.iteritems()]
12420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12421 
 
12422 
  def __eq__(self, other):
12423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12424 
 
12425 
  def __ne__(self, other):
12426 
    return not (self == other)
12427 
 
12428 
class markOrderDoaRequestAuthorized_args:
12429 
  """
12430 
  Attributes:
12431 
   - orderId
12432 
   - isAuthorized
12433 
  """
12434 
 
12435 
  thrift_spec = (
12436 
    None, # 0
12437 
    (1, TType.I64, 'orderId', None, None, ), # 1
12438 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12439 
  )
12440 
 
12441 
  def __init__(self, orderId=None, isAuthorized=None,):
12442 
    self.orderId = orderId
12443 
    self.isAuthorized = isAuthorized
12444 
 
12445 
  def read(self, iprot):
12446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12448 
      return
12449 
    iprot.readStructBegin()
12450 
    while True:
12451 
      (fname, ftype, fid) = iprot.readFieldBegin()
12452 
      if ftype == TType.STOP:
12453 
        break
12454 
      if fid == 1:
12455 
        if ftype == TType.I64:
12456 
          self.orderId = iprot.readI64();
12457 
        else:
12458 
          iprot.skip(ftype)
12459 
      elif fid == 2:
12460 
        if ftype == TType.BOOL:
12461 
          self.isAuthorized = iprot.readBool();
12462 
        else:
12463 
          iprot.skip(ftype)
12464 
      else:
12465 
        iprot.skip(ftype)
12466 
      iprot.readFieldEnd()
12467 
    iprot.readStructEnd()
12468 
 
12469 
  def write(self, oprot):
12470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12472 
      return
12473 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12474 
    if self.orderId is not None:
12475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12476 
      oprot.writeI64(self.orderId)
12477 
      oprot.writeFieldEnd()
12478 
    if self.isAuthorized is not None:
12479 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12480 
      oprot.writeBool(self.isAuthorized)
12481 
      oprot.writeFieldEnd()
12482 
    oprot.writeFieldStop()
12483 
    oprot.writeStructEnd()
12484 
 
12485 
  def validate(self):
12486 
    return
12487 
 
12488 
 
12489 
  def __repr__(self):
12490 
    L = ['%s=%r' % (key, value)
12491 
      for key, value in self.__dict__.iteritems()]
12492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12493 
 
12494 
  def __eq__(self, other):
12495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12496 
 
12497 
  def __ne__(self, other):
12498 
    return not (self == other)
12499 
 
12500 
class markOrderDoaRequestAuthorized_result:
12501 
  """
12502 
  Attributes:
12503 
   - success
12504 
   - ex
12505 
  """
12506 
 
12507 
  thrift_spec = (
12508 
    (0, TType.BOOL, 'success', None, None, ), # 0
12509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12510 
  )
12511 
 
12512 
  def __init__(self, success=None, ex=None,):
12513 
    self.success = success
12514 
    self.ex = ex
12515 
 
12516 
  def read(self, iprot):
12517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12519 
      return
12520 
    iprot.readStructBegin()
12521 
    while True:
12522 
      (fname, ftype, fid) = iprot.readFieldBegin()
12523 
      if ftype == TType.STOP:
12524 
        break
12525 
      if fid == 0:
12526 
        if ftype == TType.BOOL:
12527 
          self.success = iprot.readBool();
12528 
        else:
12529 
          iprot.skip(ftype)
12530 
      elif fid == 1:
12531 
        if ftype == TType.STRUCT:
12532 
          self.ex = TransactionServiceException()
12533 
          self.ex.read(iprot)
12534 
        else:
12535 
          iprot.skip(ftype)
12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
12545 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12546 
    if self.success is not None:
12547 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12548 
      oprot.writeBool(self.success)
12549 
      oprot.writeFieldEnd()
12550 
    if self.ex is not None:
12551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12552 
      self.ex.write(oprot)
12553 
      oprot.writeFieldEnd()
12554 
    oprot.writeFieldStop()
12555 
    oprot.writeStructEnd()
12556 
 
12557 
  def validate(self):
12558 
    return
12559 
 
12560 
 
12561 
  def __repr__(self):
12562 
    L = ['%s=%r' % (key, value)
12563 
      for key, value in self.__dict__.iteritems()]
12564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12565 
 
12566 
  def __eq__(self, other):
12567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12568 
 
12569 
  def __ne__(self, other):
12570 
    return not (self == other)
12571 
 
4488 rajveer 12572 
class markOrderReturnRequestReceived_args:
12573 
  """
12574 
  Attributes:
12575 
   - orderId
12576 
  """
12577 
 
12578 
  thrift_spec = (
12579 
    None, # 0
12580 
    (1, TType.I64, 'orderId', None, None, ), # 1
12581 
  )
12582 
 
12583 
  def __init__(self, orderId=None,):
12584 
    self.orderId = orderId
12585 
 
12586 
  def read(self, iprot):
12587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12589 
      return
12590 
    iprot.readStructBegin()
12591 
    while True:
12592 
      (fname, ftype, fid) = iprot.readFieldBegin()
12593 
      if ftype == TType.STOP:
12594 
        break
12595 
      if fid == 1:
12596 
        if ftype == TType.I64:
12597 
          self.orderId = iprot.readI64();
12598 
        else:
12599 
          iprot.skip(ftype)
12600 
      else:
12601 
        iprot.skip(ftype)
12602 
      iprot.readFieldEnd()
12603 
    iprot.readStructEnd()
12604 
 
12605 
  def write(self, oprot):
12606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12608 
      return
12609 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12610 
    if self.orderId is not None:
12611 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12612 
      oprot.writeI64(self.orderId)
12613 
      oprot.writeFieldEnd()
12614 
    oprot.writeFieldStop()
12615 
    oprot.writeStructEnd()
12616 
 
12617 
  def validate(self):
12618 
    return
12619 
 
12620 
 
12621 
  def __repr__(self):
12622 
    L = ['%s=%r' % (key, value)
12623 
      for key, value in self.__dict__.iteritems()]
12624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12625 
 
12626 
  def __eq__(self, other):
12627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12628 
 
12629 
  def __ne__(self, other):
12630 
    return not (self == other)
12631 
 
12632 
class markOrderReturnRequestReceived_result:
12633 
  """
12634 
  Attributes:
12635 
   - success
12636 
   - ex
12637 
  """
12638 
 
12639 
  thrift_spec = (
12640 
    (0, TType.BOOL, 'success', None, None, ), # 0
12641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12642 
  )
12643 
 
12644 
  def __init__(self, success=None, ex=None,):
12645 
    self.success = success
12646 
    self.ex = ex
12647 
 
12648 
  def read(self, iprot):
12649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12651 
      return
12652 
    iprot.readStructBegin()
12653 
    while True:
12654 
      (fname, ftype, fid) = iprot.readFieldBegin()
12655 
      if ftype == TType.STOP:
12656 
        break
12657 
      if fid == 0:
12658 
        if ftype == TType.BOOL:
12659 
          self.success = iprot.readBool();
12660 
        else:
12661 
          iprot.skip(ftype)
12662 
      elif fid == 1:
12663 
        if ftype == TType.STRUCT:
12664 
          self.ex = TransactionServiceException()
12665 
          self.ex.read(iprot)
12666 
        else:
12667 
          iprot.skip(ftype)
12668 
      else:
12669 
        iprot.skip(ftype)
12670 
      iprot.readFieldEnd()
12671 
    iprot.readStructEnd()
12672 
 
12673 
  def write(self, oprot):
12674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12676 
      return
12677 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12678 
    if self.success is not None:
12679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12680 
      oprot.writeBool(self.success)
12681 
      oprot.writeFieldEnd()
12682 
    if self.ex is not None:
12683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12684 
      self.ex.write(oprot)
12685 
      oprot.writeFieldEnd()
12686 
    oprot.writeFieldStop()
12687 
    oprot.writeStructEnd()
12688 
 
12689 
  def validate(self):
12690 
    return
12691 
 
12692 
 
12693 
  def __repr__(self):
12694 
    L = ['%s=%r' % (key, value)
12695 
      for key, value in self.__dict__.iteritems()]
12696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12697 
 
12698 
  def __eq__(self, other):
12699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12700 
 
12701 
  def __ne__(self, other):
12702 
    return not (self == other)
12703 
 
12704 
class markOrderReturnRequestAuthorized_args:
12705 
  """
12706 
  Attributes:
12707 
   - orderId
12708 
   - isAuthorized
12709 
  """
12710 
 
12711 
  thrift_spec = (
12712 
    None, # 0
12713 
    (1, TType.I64, 'orderId', None, None, ), # 1
12714 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12715 
  )
12716 
 
12717 
  def __init__(self, orderId=None, isAuthorized=None,):
12718 
    self.orderId = orderId
12719 
    self.isAuthorized = isAuthorized
12720 
 
12721 
  def read(self, iprot):
12722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12724 
      return
12725 
    iprot.readStructBegin()
12726 
    while True:
12727 
      (fname, ftype, fid) = iprot.readFieldBegin()
12728 
      if ftype == TType.STOP:
12729 
        break
12730 
      if fid == 1:
12731 
        if ftype == TType.I64:
12732 
          self.orderId = iprot.readI64();
12733 
        else:
12734 
          iprot.skip(ftype)
12735 
      elif fid == 2:
12736 
        if ftype == TType.BOOL:
12737 
          self.isAuthorized = iprot.readBool();
12738 
        else:
12739 
          iprot.skip(ftype)
12740 
      else:
12741 
        iprot.skip(ftype)
12742 
      iprot.readFieldEnd()
12743 
    iprot.readStructEnd()
12744 
 
12745 
  def write(self, oprot):
12746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12748 
      return
12749 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12750 
    if self.orderId is not None:
12751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12752 
      oprot.writeI64(self.orderId)
12753 
      oprot.writeFieldEnd()
12754 
    if self.isAuthorized is not None:
12755 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12756 
      oprot.writeBool(self.isAuthorized)
12757 
      oprot.writeFieldEnd()
12758 
    oprot.writeFieldStop()
12759 
    oprot.writeStructEnd()
12760 
 
12761 
  def validate(self):
12762 
    return
12763 
 
12764 
 
12765 
  def __repr__(self):
12766 
    L = ['%s=%r' % (key, value)
12767 
      for key, value in self.__dict__.iteritems()]
12768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12769 
 
12770 
  def __eq__(self, other):
12771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12772 
 
12773 
  def __ne__(self, other):
12774 
    return not (self == other)
12775 
 
12776 
class markOrderReturnRequestAuthorized_result:
12777 
  """
12778 
  Attributes:
12779 
   - success
12780 
   - ex
12781 
  """
12782 
 
12783 
  thrift_spec = (
12784 
    (0, TType.BOOL, 'success', None, None, ), # 0
12785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12786 
  )
12787 
 
12788 
  def __init__(self, success=None, ex=None,):
12789 
    self.success = success
12790 
    self.ex = ex
12791 
 
12792 
  def read(self, iprot):
12793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12795 
      return
12796 
    iprot.readStructBegin()
12797 
    while True:
12798 
      (fname, ftype, fid) = iprot.readFieldBegin()
12799 
      if ftype == TType.STOP:
12800 
        break
12801 
      if fid == 0:
12802 
        if ftype == TType.BOOL:
12803 
          self.success = iprot.readBool();
12804 
        else:
12805 
          iprot.skip(ftype)
12806 
      elif fid == 1:
12807 
        if ftype == TType.STRUCT:
12808 
          self.ex = TransactionServiceException()
12809 
          self.ex.read(iprot)
12810 
        else:
12811 
          iprot.skip(ftype)
12812 
      else:
12813 
        iprot.skip(ftype)
12814 
      iprot.readFieldEnd()
12815 
    iprot.readStructEnd()
12816 
 
12817 
  def write(self, oprot):
12818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12820 
      return
12821 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12822 
    if self.success is not None:
12823 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12824 
      oprot.writeBool(self.success)
12825 
      oprot.writeFieldEnd()
12826 
    if self.ex is not None:
12827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12828 
      self.ex.write(oprot)
12829 
      oprot.writeFieldEnd()
12830 
    oprot.writeFieldStop()
12831 
    oprot.writeStructEnd()
12832 
 
12833 
  def validate(self):
12834 
    return
12835 
 
12836 
 
12837 
  def __repr__(self):
12838 
    L = ['%s=%r' % (key, value)
12839 
      for key, value in self.__dict__.iteritems()]
12840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12841 
 
12842 
  def __eq__(self, other):
12843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12844 
 
12845 
  def __ne__(self, other):
12846 
    return not (self == other)
12847 
 
2536 chandransh 12848 
class requestPickupNumber_args:
12849 
  """
12850 
  Attributes:
12851 
   - orderId
4579 rajveer 12852 
   - providerId
2536 chandransh 12853 
  """
12854 
 
12855 
  thrift_spec = (
12856 
    None, # 0
12857 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12858 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12859 
  )
12860 
 
4579 rajveer 12861 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12862 
    self.orderId = orderId
4579 rajveer 12863 
    self.providerId = providerId
2536 chandransh 12864 
 
12865 
  def read(self, iprot):
12866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12868 
      return
12869 
    iprot.readStructBegin()
12870 
    while True:
12871 
      (fname, ftype, fid) = iprot.readFieldBegin()
12872 
      if ftype == TType.STOP:
12873 
        break
12874 
      if fid == 1:
12875 
        if ftype == TType.I64:
12876 
          self.orderId = iprot.readI64();
12877 
        else:
12878 
          iprot.skip(ftype)
4579 rajveer 12879 
      elif fid == 2:
12880 
        if ftype == TType.I64:
12881 
          self.providerId = iprot.readI64();
12882 
        else:
12883 
          iprot.skip(ftype)
2536 chandransh 12884 
      else:
12885 
        iprot.skip(ftype)
12886 
      iprot.readFieldEnd()
12887 
    iprot.readStructEnd()
12888 
 
12889 
  def write(self, oprot):
12890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12892 
      return
12893 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12894 
    if self.orderId is not None:
2536 chandransh 12895 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12896 
      oprot.writeI64(self.orderId)
12897 
      oprot.writeFieldEnd()
4579 rajveer 12898 
    if self.providerId is not None:
12899 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12900 
      oprot.writeI64(self.providerId)
12901 
      oprot.writeFieldEnd()
2536 chandransh 12902 
    oprot.writeFieldStop()
12903 
    oprot.writeStructEnd()
12904 
 
3431 rajveer 12905 
  def validate(self):
12906 
    return
12907 
 
12908 
 
2536 chandransh 12909 
  def __repr__(self):
12910 
    L = ['%s=%r' % (key, value)
12911 
      for key, value in self.__dict__.iteritems()]
12912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12913 
 
12914 
  def __eq__(self, other):
12915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12916 
 
12917 
  def __ne__(self, other):
12918 
    return not (self == other)
12919 
 
12920 
class requestPickupNumber_result:
12921 
  """
12922 
  Attributes:
12923 
   - success
12924 
   - ex
12925 
  """
12926 
 
12927 
  thrift_spec = (
12928 
    (0, TType.BOOL, 'success', None, None, ), # 0
12929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12930 
  )
12931 
 
12932 
  def __init__(self, success=None, ex=None,):
12933 
    self.success = success
12934 
    self.ex = ex
12935 
 
12936 
  def read(self, iprot):
12937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12939 
      return
12940 
    iprot.readStructBegin()
12941 
    while True:
12942 
      (fname, ftype, fid) = iprot.readFieldBegin()
12943 
      if ftype == TType.STOP:
12944 
        break
12945 
      if fid == 0:
12946 
        if ftype == TType.BOOL:
12947 
          self.success = iprot.readBool();
12948 
        else:
12949 
          iprot.skip(ftype)
12950 
      elif fid == 1:
12951 
        if ftype == TType.STRUCT:
12952 
          self.ex = TransactionServiceException()
12953 
          self.ex.read(iprot)
12954 
        else:
12955 
          iprot.skip(ftype)
12956 
      else:
12957 
        iprot.skip(ftype)
12958 
      iprot.readFieldEnd()
12959 
    iprot.readStructEnd()
12960 
 
12961 
  def write(self, oprot):
12962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12964 
      return
12965 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12966 
    if self.success is not None:
2536 chandransh 12967 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12968 
      oprot.writeBool(self.success)
12969 
      oprot.writeFieldEnd()
3431 rajveer 12970 
    if self.ex is not None:
2536 chandransh 12971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12972 
      self.ex.write(oprot)
12973 
      oprot.writeFieldEnd()
12974 
    oprot.writeFieldStop()
12975 
    oprot.writeStructEnd()
12976 
 
3431 rajveer 12977 
  def validate(self):
12978 
    return
12979 
 
12980 
 
2536 chandransh 12981 
  def __repr__(self):
12982 
    L = ['%s=%r' % (key, value)
12983 
      for key, value in self.__dict__.iteritems()]
12984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12985 
 
12986 
  def __eq__(self, other):
12987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12988 
 
12989 
  def __ne__(self, other):
12990 
    return not (self == other)
12991 
 
12992 
class authorizePickup_args:
12993 
  """
12994 
  Attributes:
12995 
   - orderId
12996 
   - pickupNumber
4602 rajveer 12997 
   - providerId
2536 chandransh 12998 
  """
12999 
 
13000 
  thrift_spec = (
13001 
    None, # 0
13002 
    (1, TType.I64, 'orderId', None, None, ), # 1
13003 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 13004 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 13005 
  )
13006 
 
4602 rajveer 13007 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 13008 
    self.orderId = orderId
13009 
    self.pickupNumber = pickupNumber
4602 rajveer 13010 
    self.providerId = providerId
2536 chandransh 13011 
 
13012 
  def read(self, iprot):
13013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13015 
      return
13016 
    iprot.readStructBegin()
13017 
    while True:
13018 
      (fname, ftype, fid) = iprot.readFieldBegin()
13019 
      if ftype == TType.STOP:
13020 
        break
13021 
      if fid == 1:
13022 
        if ftype == TType.I64:
13023 
          self.orderId = iprot.readI64();
13024 
        else:
13025 
          iprot.skip(ftype)
13026 
      elif fid == 2:
13027 
        if ftype == TType.STRING:
13028 
          self.pickupNumber = iprot.readString();
13029 
        else:
13030 
          iprot.skip(ftype)
4602 rajveer 13031 
      elif fid == 3:
13032 
        if ftype == TType.I64:
13033 
          self.providerId = iprot.readI64();
13034 
        else:
13035 
          iprot.skip(ftype)
2536 chandransh 13036 
      else:
13037 
        iprot.skip(ftype)
13038 
      iprot.readFieldEnd()
13039 
    iprot.readStructEnd()
13040 
 
13041 
  def write(self, oprot):
13042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13044 
      return
13045 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 13046 
    if self.orderId is not None:
2536 chandransh 13047 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13048 
      oprot.writeI64(self.orderId)
13049 
      oprot.writeFieldEnd()
3431 rajveer 13050 
    if self.pickupNumber is not None:
2536 chandransh 13051 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
13052 
      oprot.writeString(self.pickupNumber)
13053 
      oprot.writeFieldEnd()
4602 rajveer 13054 
    if self.providerId is not None:
13055 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
13056 
      oprot.writeI64(self.providerId)
13057 
      oprot.writeFieldEnd()
2536 chandransh 13058 
    oprot.writeFieldStop()
13059 
    oprot.writeStructEnd()
13060 
 
3431 rajveer 13061 
  def validate(self):
13062 
    return
13063 
 
13064 
 
2536 chandransh 13065 
  def __repr__(self):
13066 
    L = ['%s=%r' % (key, value)
13067 
      for key, value in self.__dict__.iteritems()]
13068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13069 
 
13070 
  def __eq__(self, other):
13071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13072 
 
13073 
  def __ne__(self, other):
13074 
    return not (self == other)
13075 
 
13076 
class authorizePickup_result:
13077 
  """
13078 
  Attributes:
13079 
   - success
13080 
   - ex
13081 
  """
13082 
 
13083 
  thrift_spec = (
13084 
    (0, TType.BOOL, 'success', None, None, ), # 0
13085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13086 
  )
13087 
 
13088 
  def __init__(self, success=None, ex=None,):
13089 
    self.success = success
13090 
    self.ex = ex
13091 
 
13092 
  def read(self, iprot):
13093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13095 
      return
13096 
    iprot.readStructBegin()
13097 
    while True:
13098 
      (fname, ftype, fid) = iprot.readFieldBegin()
13099 
      if ftype == TType.STOP:
13100 
        break
13101 
      if fid == 0:
13102 
        if ftype == TType.BOOL:
13103 
          self.success = iprot.readBool();
13104 
        else:
13105 
          iprot.skip(ftype)
13106 
      elif fid == 1:
13107 
        if ftype == TType.STRUCT:
13108 
          self.ex = TransactionServiceException()
13109 
          self.ex.read(iprot)
13110 
        else:
13111 
          iprot.skip(ftype)
13112 
      else:
13113 
        iprot.skip(ftype)
13114 
      iprot.readFieldEnd()
13115 
    iprot.readStructEnd()
13116 
 
13117 
  def write(self, oprot):
13118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13120 
      return
13121 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 13122 
    if self.success is not None:
2536 chandransh 13123 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13124 
      oprot.writeBool(self.success)
13125 
      oprot.writeFieldEnd()
3431 rajveer 13126 
    if self.ex is not None:
2536 chandransh 13127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13128 
      self.ex.write(oprot)
13129 
      oprot.writeFieldEnd()
13130 
    oprot.writeFieldStop()
13131 
    oprot.writeStructEnd()
13132 
 
3431 rajveer 13133 
  def validate(self):
13134 
    return
13135 
 
13136 
 
2536 chandransh 13137 
  def __repr__(self):
13138 
    L = ['%s=%r' % (key, value)
13139 
      for key, value in self.__dict__.iteritems()]
13140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13141 
 
13142 
  def __eq__(self, other):
13143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13144 
 
13145 
  def __ne__(self, other):
13146 
    return not (self == other)
13147 
 
2764 chandransh 13148 
class markDoasAsPickedUp_args:
13149 
  """
13150 
  Attributes:
13151 
   - providerId
13152 
   - pickupDetails
13153 
  """
13154 
 
13155 
  thrift_spec = (
13156 
    None, # 0
13157 
    (1, TType.I64, 'providerId', None, None, ), # 1
13158 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13159 
  )
13160 
 
13161 
  def __init__(self, providerId=None, pickupDetails=None,):
13162 
    self.providerId = providerId
13163 
    self.pickupDetails = pickupDetails
13164 
 
13165 
  def read(self, iprot):
13166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13168 
      return
13169 
    iprot.readStructBegin()
13170 
    while True:
13171 
      (fname, ftype, fid) = iprot.readFieldBegin()
13172 
      if ftype == TType.STOP:
13173 
        break
13174 
      if fid == 1:
13175 
        if ftype == TType.I64:
13176 
          self.providerId = iprot.readI64();
13177 
        else:
13178 
          iprot.skip(ftype)
13179 
      elif fid == 2:
13180 
        if ftype == TType.MAP:
13181 
          self.pickupDetails = {}
4783 phani.kuma 13182 
          (_ktype205, _vtype206, _size204 ) = iprot.readMapBegin()
13183 
          for _i208 in xrange(_size204):
13184 
            _key209 = iprot.readString();
13185 
            _val210 = iprot.readString();
13186 
            self.pickupDetails[_key209] = _val210
2764 chandransh 13187 
          iprot.readMapEnd()
13188 
        else:
13189 
          iprot.skip(ftype)
13190 
      else:
13191 
        iprot.skip(ftype)
13192 
      iprot.readFieldEnd()
13193 
    iprot.readStructEnd()
13194 
 
13195 
  def write(self, oprot):
13196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13198 
      return
13199 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13200 
    if self.providerId is not None:
2764 chandransh 13201 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13202 
      oprot.writeI64(self.providerId)
13203 
      oprot.writeFieldEnd()
3431 rajveer 13204 
    if self.pickupDetails is not None:
2764 chandransh 13205 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13206 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4783 phani.kuma 13207 
      for kiter211,viter212 in self.pickupDetails.items():
13208 
        oprot.writeString(kiter211)
13209 
        oprot.writeString(viter212)
2764 chandransh 13210 
      oprot.writeMapEnd()
13211 
      oprot.writeFieldEnd()
13212 
    oprot.writeFieldStop()
13213 
    oprot.writeStructEnd()
13214 
 
3431 rajveer 13215 
  def validate(self):
13216 
    return
13217 
 
13218 
 
2764 chandransh 13219 
  def __repr__(self):
13220 
    L = ['%s=%r' % (key, value)
13221 
      for key, value in self.__dict__.iteritems()]
13222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13223 
 
13224 
  def __eq__(self, other):
13225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13226 
 
13227 
  def __ne__(self, other):
13228 
    return not (self == other)
13229 
 
13230 
class markDoasAsPickedUp_result:
13231 
  """
13232 
  Attributes:
13233 
   - success
13234 
  """
13235 
 
13236 
  thrift_spec = (
13237 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13238 
  )
13239 
 
13240 
  def __init__(self, success=None,):
13241 
    self.success = success
13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 0:
13253 
        if ftype == TType.LIST:
13254 
          self.success = []
4783 phani.kuma 13255 
          (_etype216, _size213) = iprot.readListBegin()
13256 
          for _i217 in xrange(_size213):
13257 
            _elem218 = Order()
13258 
            _elem218.read(iprot)
13259 
            self.success.append(_elem218)
2764 chandransh 13260 
          iprot.readListEnd()
13261 
        else:
13262 
          iprot.skip(ftype)
13263 
      else:
13264 
        iprot.skip(ftype)
13265 
      iprot.readFieldEnd()
13266 
    iprot.readStructEnd()
13267 
 
13268 
  def write(self, oprot):
13269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13271 
      return
13272 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13273 
    if self.success is not None:
2764 chandransh 13274 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13275 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 13276 
      for iter219 in self.success:
13277 
        iter219.write(oprot)
2764 chandransh 13278 
      oprot.writeListEnd()
13279 
      oprot.writeFieldEnd()
13280 
    oprot.writeFieldStop()
13281 
    oprot.writeStructEnd()
13282 
 
3431 rajveer 13283 
  def validate(self):
13284 
    return
13285 
 
13286 
 
2764 chandransh 13287 
  def __repr__(self):
13288 
    L = ['%s=%r' % (key, value)
13289 
      for key, value in self.__dict__.iteritems()]
13290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13291 
 
13292 
  def __eq__(self, other):
13293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13294 
 
13295 
  def __ne__(self, other):
13296 
    return not (self == other)
13297 
 
4741 phani.kuma 13298 
class markReturnOrdersAsPickedUp_args:
13299 
  """
13300 
  Attributes:
13301 
   - providerId
13302 
   - pickupDetails
13303 
  """
13304 
 
13305 
  thrift_spec = (
13306 
    None, # 0
13307 
    (1, TType.I64, 'providerId', None, None, ), # 1
13308 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13309 
  )
13310 
 
13311 
  def __init__(self, providerId=None, pickupDetails=None,):
13312 
    self.providerId = providerId
13313 
    self.pickupDetails = pickupDetails
13314 
 
13315 
  def read(self, iprot):
13316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13318 
      return
13319 
    iprot.readStructBegin()
13320 
    while True:
13321 
      (fname, ftype, fid) = iprot.readFieldBegin()
13322 
      if ftype == TType.STOP:
13323 
        break
13324 
      if fid == 1:
13325 
        if ftype == TType.I64:
13326 
          self.providerId = iprot.readI64();
13327 
        else:
13328 
          iprot.skip(ftype)
13329 
      elif fid == 2:
13330 
        if ftype == TType.MAP:
13331 
          self.pickupDetails = {}
4783 phani.kuma 13332 
          (_ktype221, _vtype222, _size220 ) = iprot.readMapBegin()
13333 
          for _i224 in xrange(_size220):
13334 
            _key225 = iprot.readString();
13335 
            _val226 = iprot.readString();
13336 
            self.pickupDetails[_key225] = _val226
4741 phani.kuma 13337 
          iprot.readMapEnd()
13338 
        else:
13339 
          iprot.skip(ftype)
13340 
      else:
13341 
        iprot.skip(ftype)
13342 
      iprot.readFieldEnd()
13343 
    iprot.readStructEnd()
13344 
 
13345 
  def write(self, oprot):
13346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13348 
      return
13349 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13350 
    if self.providerId is not None:
13351 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13352 
      oprot.writeI64(self.providerId)
13353 
      oprot.writeFieldEnd()
13354 
    if self.pickupDetails is not None:
13355 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13356 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4783 phani.kuma 13357 
      for kiter227,viter228 in self.pickupDetails.items():
13358 
        oprot.writeString(kiter227)
13359 
        oprot.writeString(viter228)
4741 phani.kuma 13360 
      oprot.writeMapEnd()
13361 
      oprot.writeFieldEnd()
13362 
    oprot.writeFieldStop()
13363 
    oprot.writeStructEnd()
13364 
 
13365 
  def validate(self):
13366 
    return
13367 
 
13368 
 
13369 
  def __repr__(self):
13370 
    L = ['%s=%r' % (key, value)
13371 
      for key, value in self.__dict__.iteritems()]
13372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13373 
 
13374 
  def __eq__(self, other):
13375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13376 
 
13377 
  def __ne__(self, other):
13378 
    return not (self == other)
13379 
 
13380 
class markReturnOrdersAsPickedUp_result:
13381 
  """
13382 
  Attributes:
13383 
   - success
13384 
  """
13385 
 
13386 
  thrift_spec = (
13387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13388 
  )
13389 
 
13390 
  def __init__(self, success=None,):
13391 
    self.success = success
13392 
 
13393 
  def read(self, iprot):
13394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13396 
      return
13397 
    iprot.readStructBegin()
13398 
    while True:
13399 
      (fname, ftype, fid) = iprot.readFieldBegin()
13400 
      if ftype == TType.STOP:
13401 
        break
13402 
      if fid == 0:
13403 
        if ftype == TType.LIST:
13404 
          self.success = []
4783 phani.kuma 13405 
          (_etype232, _size229) = iprot.readListBegin()
13406 
          for _i233 in xrange(_size229):
13407 
            _elem234 = Order()
13408 
            _elem234.read(iprot)
13409 
            self.success.append(_elem234)
4741 phani.kuma 13410 
          iprot.readListEnd()
13411 
        else:
13412 
          iprot.skip(ftype)
13413 
      else:
13414 
        iprot.skip(ftype)
13415 
      iprot.readFieldEnd()
13416 
    iprot.readStructEnd()
13417 
 
13418 
  def write(self, oprot):
13419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13421 
      return
13422 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13423 
    if self.success is not None:
13424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 13426 
      for iter235 in self.success:
13427 
        iter235.write(oprot)
4741 phani.kuma 13428 
      oprot.writeListEnd()
13429 
      oprot.writeFieldEnd()
13430 
    oprot.writeFieldStop()
13431 
    oprot.writeStructEnd()
13432 
 
13433 
  def validate(self):
13434 
    return
13435 
 
13436 
 
13437 
  def __repr__(self):
13438 
    L = ['%s=%r' % (key, value)
13439 
      for key, value in self.__dict__.iteritems()]
13440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13441 
 
13442 
  def __eq__(self, other):
13443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13444 
 
13445 
  def __ne__(self, other):
13446 
    return not (self == other)
13447 
 
2616 chandransh 13448 
class receiveReturn_args:
2591 chandransh 13449 
  """
13450 
  Attributes:
13451 
   - orderId
4479 rajveer 13452 
   - receiveCondition
2591 chandransh 13453 
  """
2536 chandransh 13454 
 
2591 chandransh 13455 
  thrift_spec = (
13456 
    None, # 0
13457 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13458 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13459 
  )
13460 
 
4479 rajveer 13461 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13462 
    self.orderId = orderId
4479 rajveer 13463 
    self.receiveCondition = receiveCondition
2591 chandransh 13464 
 
13465 
  def read(self, iprot):
13466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13468 
      return
13469 
    iprot.readStructBegin()
13470 
    while True:
13471 
      (fname, ftype, fid) = iprot.readFieldBegin()
13472 
      if ftype == TType.STOP:
13473 
        break
13474 
      if fid == 1:
13475 
        if ftype == TType.I64:
13476 
          self.orderId = iprot.readI64();
13477 
        else:
13478 
          iprot.skip(ftype)
4479 rajveer 13479 
      elif fid == 2:
13480 
        if ftype == TType.I64:
13481 
          self.receiveCondition = iprot.readI64();
13482 
        else:
13483 
          iprot.skip(ftype)
2591 chandransh 13484 
      else:
13485 
        iprot.skip(ftype)
13486 
      iprot.readFieldEnd()
13487 
    iprot.readStructEnd()
13488 
 
13489 
  def write(self, oprot):
13490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13492 
      return
2616 chandransh 13493 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13494 
    if self.orderId is not None:
2591 chandransh 13495 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13496 
      oprot.writeI64(self.orderId)
13497 
      oprot.writeFieldEnd()
4479 rajveer 13498 
    if self.receiveCondition is not None:
13499 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13500 
      oprot.writeI64(self.receiveCondition)
13501 
      oprot.writeFieldEnd()
2591 chandransh 13502 
    oprot.writeFieldStop()
13503 
    oprot.writeStructEnd()
13504 
 
3431 rajveer 13505 
  def validate(self):
13506 
    return
13507 
 
13508 
 
2591 chandransh 13509 
  def __repr__(self):
13510 
    L = ['%s=%r' % (key, value)
13511 
      for key, value in self.__dict__.iteritems()]
13512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13513 
 
13514 
  def __eq__(self, other):
13515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13516 
 
13517 
  def __ne__(self, other):
13518 
    return not (self == other)
13519 
 
2616 chandransh 13520 
class receiveReturn_result:
2591 chandransh 13521 
  """
13522 
  Attributes:
13523 
   - success
13524 
   - ex
13525 
  """
13526 
 
13527 
  thrift_spec = (
13528 
    (0, TType.BOOL, 'success', None, None, ), # 0
13529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13530 
  )
13531 
 
13532 
  def __init__(self, success=None, ex=None,):
13533 
    self.success = success
13534 
    self.ex = ex
13535 
 
13536 
  def read(self, iprot):
13537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13539 
      return
13540 
    iprot.readStructBegin()
13541 
    while True:
13542 
      (fname, ftype, fid) = iprot.readFieldBegin()
13543 
      if ftype == TType.STOP:
13544 
        break
13545 
      if fid == 0:
13546 
        if ftype == TType.BOOL:
13547 
          self.success = iprot.readBool();
13548 
        else:
13549 
          iprot.skip(ftype)
13550 
      elif fid == 1:
13551 
        if ftype == TType.STRUCT:
13552 
          self.ex = TransactionServiceException()
13553 
          self.ex.read(iprot)
13554 
        else:
13555 
          iprot.skip(ftype)
13556 
      else:
13557 
        iprot.skip(ftype)
13558 
      iprot.readFieldEnd()
13559 
    iprot.readStructEnd()
13560 
 
13561 
  def write(self, oprot):
13562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13564 
      return
2616 chandransh 13565 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13566 
    if self.success is not None:
2591 chandransh 13567 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13568 
      oprot.writeBool(self.success)
13569 
      oprot.writeFieldEnd()
3431 rajveer 13570 
    if self.ex is not None:
2591 chandransh 13571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13572 
      self.ex.write(oprot)
13573 
      oprot.writeFieldEnd()
13574 
    oprot.writeFieldStop()
13575 
    oprot.writeStructEnd()
13576 
 
3431 rajveer 13577 
  def validate(self):
13578 
    return
13579 
 
13580 
 
2591 chandransh 13581 
  def __repr__(self):
13582 
    L = ['%s=%r' % (key, value)
13583 
      for key, value in self.__dict__.iteritems()]
13584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13585 
 
13586 
  def __eq__(self, other):
13587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13588 
 
13589 
  def __ne__(self, other):
13590 
    return not (self == other)
13591 
 
13592 
class validateDoa_args:
13593 
  """
13594 
  Attributes:
13595 
   - orderId
13596 
   - isValid
13597 
  """
13598 
 
13599 
  thrift_spec = (
13600 
    None, # 0
13601 
    (1, TType.I64, 'orderId', None, None, ), # 1
13602 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13603 
  )
13604 
 
13605 
  def __init__(self, orderId=None, isValid=None,):
13606 
    self.orderId = orderId
13607 
    self.isValid = isValid
13608 
 
13609 
  def read(self, iprot):
13610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13612 
      return
13613 
    iprot.readStructBegin()
13614 
    while True:
13615 
      (fname, ftype, fid) = iprot.readFieldBegin()
13616 
      if ftype == TType.STOP:
13617 
        break
13618 
      if fid == 1:
13619 
        if ftype == TType.I64:
13620 
          self.orderId = iprot.readI64();
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      elif fid == 2:
13624 
        if ftype == TType.BOOL:
13625 
          self.isValid = iprot.readBool();
13626 
        else:
13627 
          iprot.skip(ftype)
13628 
      else:
13629 
        iprot.skip(ftype)
13630 
      iprot.readFieldEnd()
13631 
    iprot.readStructEnd()
13632 
 
13633 
  def write(self, oprot):
13634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13636 
      return
13637 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13638 
    if self.orderId is not None:
2591 chandransh 13639 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13640 
      oprot.writeI64(self.orderId)
13641 
      oprot.writeFieldEnd()
3431 rajveer 13642 
    if self.isValid is not None:
2591 chandransh 13643 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13644 
      oprot.writeBool(self.isValid)
13645 
      oprot.writeFieldEnd()
13646 
    oprot.writeFieldStop()
13647 
    oprot.writeStructEnd()
13648 
 
3431 rajveer 13649 
  def validate(self):
13650 
    return
13651 
 
13652 
 
2591 chandransh 13653 
  def __repr__(self):
13654 
    L = ['%s=%r' % (key, value)
13655 
      for key, value in self.__dict__.iteritems()]
13656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13657 
 
13658 
  def __eq__(self, other):
13659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13660 
 
13661 
  def __ne__(self, other):
13662 
    return not (self == other)
13663 
 
13664 
class validateDoa_result:
13665 
  """
13666 
  Attributes:
13667 
   - success
13668 
   - ex
13669 
  """
13670 
 
13671 
  thrift_spec = (
13672 
    (0, TType.BOOL, 'success', None, None, ), # 0
13673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13674 
  )
13675 
 
13676 
  def __init__(self, success=None, ex=None,):
13677 
    self.success = success
13678 
    self.ex = ex
13679 
 
13680 
  def read(self, iprot):
13681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13683 
      return
13684 
    iprot.readStructBegin()
13685 
    while True:
13686 
      (fname, ftype, fid) = iprot.readFieldBegin()
13687 
      if ftype == TType.STOP:
13688 
        break
13689 
      if fid == 0:
13690 
        if ftype == TType.BOOL:
13691 
          self.success = iprot.readBool();
13692 
        else:
13693 
          iprot.skip(ftype)
13694 
      elif fid == 1:
13695 
        if ftype == TType.STRUCT:
13696 
          self.ex = TransactionServiceException()
13697 
          self.ex.read(iprot)
13698 
        else:
13699 
          iprot.skip(ftype)
13700 
      else:
13701 
        iprot.skip(ftype)
13702 
      iprot.readFieldEnd()
13703 
    iprot.readStructEnd()
13704 
 
13705 
  def write(self, oprot):
13706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13708 
      return
13709 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13710 
    if self.success is not None:
2591 chandransh 13711 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13712 
      oprot.writeBool(self.success)
13713 
      oprot.writeFieldEnd()
3431 rajveer 13714 
    if self.ex is not None:
2591 chandransh 13715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13716 
      self.ex.write(oprot)
13717 
      oprot.writeFieldEnd()
13718 
    oprot.writeFieldStop()
13719 
    oprot.writeStructEnd()
13720 
 
3431 rajveer 13721 
  def validate(self):
13722 
    return
13723 
 
13724 
 
2591 chandransh 13725 
  def __repr__(self):
13726 
    L = ['%s=%r' % (key, value)
13727 
      for key, value in self.__dict__.iteritems()]
13728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13729 
 
13730 
  def __eq__(self, other):
13731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13732 
 
13733 
  def __ne__(self, other):
13734 
    return not (self == other)
13735 
 
4495 rajveer 13736 
class validateReturnProduct_args:
13737 
  """
13738 
  Attributes:
13739 
   - orderId
13740 
   - isUsable
13741 
  """
13742 
 
13743 
  thrift_spec = (
13744 
    None, # 0
13745 
    (1, TType.I64, 'orderId', None, None, ), # 1
13746 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13747 
  )
13748 
 
13749 
  def __init__(self, orderId=None, isUsable=None,):
13750 
    self.orderId = orderId
13751 
    self.isUsable = isUsable
13752 
 
13753 
  def read(self, iprot):
13754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13756 
      return
13757 
    iprot.readStructBegin()
13758 
    while True:
13759 
      (fname, ftype, fid) = iprot.readFieldBegin()
13760 
      if ftype == TType.STOP:
13761 
        break
13762 
      if fid == 1:
13763 
        if ftype == TType.I64:
13764 
          self.orderId = iprot.readI64();
13765 
        else:
13766 
          iprot.skip(ftype)
13767 
      elif fid == 2:
13768 
        if ftype == TType.BOOL:
13769 
          self.isUsable = iprot.readBool();
13770 
        else:
13771 
          iprot.skip(ftype)
13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
13781 
    oprot.writeStructBegin('validateReturnProduct_args')
13782 
    if self.orderId is not None:
13783 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13784 
      oprot.writeI64(self.orderId)
13785 
      oprot.writeFieldEnd()
13786 
    if self.isUsable is not None:
13787 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13788 
      oprot.writeBool(self.isUsable)
13789 
      oprot.writeFieldEnd()
13790 
    oprot.writeFieldStop()
13791 
    oprot.writeStructEnd()
13792 
 
13793 
  def validate(self):
13794 
    return
13795 
 
13796 
 
13797 
  def __repr__(self):
13798 
    L = ['%s=%r' % (key, value)
13799 
      for key, value in self.__dict__.iteritems()]
13800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13801 
 
13802 
  def __eq__(self, other):
13803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13804 
 
13805 
  def __ne__(self, other):
13806 
    return not (self == other)
13807 
 
13808 
class validateReturnProduct_result:
13809 
  """
13810 
  Attributes:
13811 
   - success
13812 
   - ex
13813 
  """
13814 
 
13815 
  thrift_spec = (
13816 
    (0, TType.BOOL, 'success', None, None, ), # 0
13817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13818 
  )
13819 
 
13820 
  def __init__(self, success=None, ex=None,):
13821 
    self.success = success
13822 
    self.ex = ex
13823 
 
13824 
  def read(self, iprot):
13825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13827 
      return
13828 
    iprot.readStructBegin()
13829 
    while True:
13830 
      (fname, ftype, fid) = iprot.readFieldBegin()
13831 
      if ftype == TType.STOP:
13832 
        break
13833 
      if fid == 0:
13834 
        if ftype == TType.BOOL:
13835 
          self.success = iprot.readBool();
13836 
        else:
13837 
          iprot.skip(ftype)
13838 
      elif fid == 1:
13839 
        if ftype == TType.STRUCT:
13840 
          self.ex = TransactionServiceException()
13841 
          self.ex.read(iprot)
13842 
        else:
13843 
          iprot.skip(ftype)
13844 
      else:
13845 
        iprot.skip(ftype)
13846 
      iprot.readFieldEnd()
13847 
    iprot.readStructEnd()
13848 
 
13849 
  def write(self, oprot):
13850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13852 
      return
13853 
    oprot.writeStructBegin('validateReturnProduct_result')
13854 
    if self.success is not None:
13855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13856 
      oprot.writeBool(self.success)
13857 
      oprot.writeFieldEnd()
13858 
    if self.ex is not None:
13859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13860 
      self.ex.write(oprot)
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 
 
2616 chandransh 13880 
class reshipOrder_args:
13881 
  """
13882 
  Attributes:
13883 
   - orderId
13884 
  """
2591 chandransh 13885 
 
2616 chandransh 13886 
  thrift_spec = (
13887 
    None, # 0
13888 
    (1, TType.I64, 'orderId', None, None, ), # 1
13889 
  )
13890 
 
13891 
  def __init__(self, orderId=None,):
13892 
    self.orderId = orderId
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.I64:
13905 
          self.orderId = iprot.readI64();
13906 
        else:
13907 
          iprot.skip(ftype)
13908 
      else:
13909 
        iprot.skip(ftype)
13910 
      iprot.readFieldEnd()
13911 
    iprot.readStructEnd()
13912 
 
13913 
  def write(self, oprot):
13914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13916 
      return
13917 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13918 
    if self.orderId is not None:
2616 chandransh 13919 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13920 
      oprot.writeI64(self.orderId)
13921 
      oprot.writeFieldEnd()
13922 
    oprot.writeFieldStop()
13923 
    oprot.writeStructEnd()
13924 
 
3431 rajveer 13925 
  def validate(self):
13926 
    return
13927 
 
13928 
 
2616 chandransh 13929 
  def __repr__(self):
13930 
    L = ['%s=%r' % (key, value)
13931 
      for key, value in self.__dict__.iteritems()]
13932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13933 
 
13934 
  def __eq__(self, other):
13935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13936 
 
13937 
  def __ne__(self, other):
13938 
    return not (self == other)
13939 
 
13940 
class reshipOrder_result:
13941 
  """
13942 
  Attributes:
13943 
   - success
13944 
   - ex
13945 
  """
13946 
 
13947 
  thrift_spec = (
13948 
    (0, TType.I64, 'success', None, None, ), # 0
13949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13950 
  )
13951 
 
13952 
  def __init__(self, success=None, ex=None,):
13953 
    self.success = success
13954 
    self.ex = ex
13955 
 
13956 
  def read(self, iprot):
13957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13959 
      return
13960 
    iprot.readStructBegin()
13961 
    while True:
13962 
      (fname, ftype, fid) = iprot.readFieldBegin()
13963 
      if ftype == TType.STOP:
13964 
        break
13965 
      if fid == 0:
13966 
        if ftype == TType.I64:
13967 
          self.success = iprot.readI64();
13968 
        else:
13969 
          iprot.skip(ftype)
13970 
      elif fid == 1:
13971 
        if ftype == TType.STRUCT:
13972 
          self.ex = TransactionServiceException()
13973 
          self.ex.read(iprot)
13974 
        else:
13975 
          iprot.skip(ftype)
13976 
      else:
13977 
        iprot.skip(ftype)
13978 
      iprot.readFieldEnd()
13979 
    iprot.readStructEnd()
13980 
 
13981 
  def write(self, oprot):
13982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13984 
      return
13985 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13986 
    if self.success is not None:
2616 chandransh 13987 
      oprot.writeFieldBegin('success', TType.I64, 0)
13988 
      oprot.writeI64(self.success)
13989 
      oprot.writeFieldEnd()
3431 rajveer 13990 
    if self.ex is not None:
2616 chandransh 13991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13992 
      self.ex.write(oprot)
13993 
      oprot.writeFieldEnd()
13994 
    oprot.writeFieldStop()
13995 
    oprot.writeStructEnd()
13996 
 
3431 rajveer 13997 
  def validate(self):
13998 
    return
13999 
 
14000 
 
2616 chandransh 14001 
  def __repr__(self):
14002 
    L = ['%s=%r' % (key, value)
14003 
      for key, value in self.__dict__.iteritems()]
14004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14005 
 
14006 
  def __eq__(self, other):
14007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14008 
 
14009 
  def __ne__(self, other):
14010 
    return not (self == other)
14011 
 
14012 
class refundOrder_args:
14013 
  """
14014 
  Attributes:
14015 
   - orderId
3226 chandransh 14016 
   - refundedBy
14017 
   - reason
2616 chandransh 14018 
  """
14019 
 
14020 
  thrift_spec = (
14021 
    None, # 0
14022 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 14023 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14024 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 14025 
  )
14026 
 
3226 chandransh 14027 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 14028 
    self.orderId = orderId
3226 chandransh 14029 
    self.refundedBy = refundedBy
14030 
    self.reason = reason
2616 chandransh 14031 
 
14032 
  def read(self, iprot):
14033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14035 
      return
14036 
    iprot.readStructBegin()
14037 
    while True:
14038 
      (fname, ftype, fid) = iprot.readFieldBegin()
14039 
      if ftype == TType.STOP:
14040 
        break
14041 
      if fid == 1:
14042 
        if ftype == TType.I64:
14043 
          self.orderId = iprot.readI64();
14044 
        else:
14045 
          iprot.skip(ftype)
3226 chandransh 14046 
      elif fid == 2:
14047 
        if ftype == TType.STRING:
14048 
          self.refundedBy = iprot.readString();
14049 
        else:
14050 
          iprot.skip(ftype)
14051 
      elif fid == 3:
14052 
        if ftype == TType.STRING:
14053 
          self.reason = iprot.readString();
14054 
        else:
14055 
          iprot.skip(ftype)
2616 chandransh 14056 
      else:
14057 
        iprot.skip(ftype)
14058 
      iprot.readFieldEnd()
14059 
    iprot.readStructEnd()
14060 
 
14061 
  def write(self, oprot):
14062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14064 
      return
14065 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 14066 
    if self.orderId is not None:
2616 chandransh 14067 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14068 
      oprot.writeI64(self.orderId)
14069 
      oprot.writeFieldEnd()
3431 rajveer 14070 
    if self.refundedBy is not None:
3226 chandransh 14071 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14072 
      oprot.writeString(self.refundedBy)
14073 
      oprot.writeFieldEnd()
3431 rajveer 14074 
    if self.reason is not None:
3226 chandransh 14075 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14076 
      oprot.writeString(self.reason)
14077 
      oprot.writeFieldEnd()
2616 chandransh 14078 
    oprot.writeFieldStop()
14079 
    oprot.writeStructEnd()
14080 
 
3431 rajveer 14081 
  def validate(self):
14082 
    return
14083 
 
14084 
 
2616 chandransh 14085 
  def __repr__(self):
14086 
    L = ['%s=%r' % (key, value)
14087 
      for key, value in self.__dict__.iteritems()]
14088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14089 
 
14090 
  def __eq__(self, other):
14091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14092 
 
14093 
  def __ne__(self, other):
14094 
    return not (self == other)
14095 
 
14096 
class refundOrder_result:
14097 
  """
14098 
  Attributes:
14099 
   - success
14100 
   - ex
14101 
  """
14102 
 
14103 
  thrift_spec = (
14104 
    (0, TType.BOOL, 'success', None, None, ), # 0
14105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14106 
  )
14107 
 
14108 
  def __init__(self, success=None, ex=None,):
14109 
    self.success = success
14110 
    self.ex = ex
14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
14121 
      if fid == 0:
14122 
        if ftype == TType.BOOL:
14123 
          self.success = iprot.readBool();
14124 
        else:
14125 
          iprot.skip(ftype)
14126 
      elif fid == 1:
14127 
        if ftype == TType.STRUCT:
14128 
          self.ex = TransactionServiceException()
14129 
          self.ex.read(iprot)
14130 
        else:
14131 
          iprot.skip(ftype)
14132 
      else:
14133 
        iprot.skip(ftype)
14134 
      iprot.readFieldEnd()
14135 
    iprot.readStructEnd()
14136 
 
14137 
  def write(self, oprot):
14138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14140 
      return
14141 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 14142 
    if self.success is not None:
2616 chandransh 14143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14144 
      oprot.writeBool(self.success)
14145 
      oprot.writeFieldEnd()
3431 rajveer 14146 
    if self.ex is not None:
2616 chandransh 14147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14148 
      self.ex.write(oprot)
14149 
      oprot.writeFieldEnd()
14150 
    oprot.writeFieldStop()
14151 
    oprot.writeStructEnd()
14152 
 
3431 rajveer 14153 
  def validate(self):
14154 
    return
14155 
 
14156 
 
2616 chandransh 14157 
  def __repr__(self):
14158 
    L = ['%s=%r' % (key, value)
14159 
      for key, value in self.__dict__.iteritems()]
14160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14161 
 
14162 
  def __eq__(self, other):
14163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14164 
 
14165 
  def __ne__(self, other):
14166 
    return not (self == other)
14167 
 
2690 chandransh 14168 
class getReturnOrders_args:
14169 
  """
14170 
  Attributes:
14171 
   - warehouseId
14172 
   - fromDate
14173 
   - toDate
14174 
  """
2616 chandransh 14175 
 
2690 chandransh 14176 
  thrift_spec = (
14177 
    None, # 0
14178 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14179 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14180 
    (3, TType.I64, 'toDate', None, None, ), # 3
14181 
  )
14182 
 
14183 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14184 
    self.warehouseId = warehouseId
14185 
    self.fromDate = fromDate
14186 
    self.toDate = toDate
14187 
 
14188 
  def read(self, iprot):
14189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14191 
      return
14192 
    iprot.readStructBegin()
14193 
    while True:
14194 
      (fname, ftype, fid) = iprot.readFieldBegin()
14195 
      if ftype == TType.STOP:
14196 
        break
14197 
      if fid == 1:
14198 
        if ftype == TType.I64:
14199 
          self.warehouseId = iprot.readI64();
14200 
        else:
14201 
          iprot.skip(ftype)
14202 
      elif fid == 2:
14203 
        if ftype == TType.I64:
14204 
          self.fromDate = iprot.readI64();
14205 
        else:
14206 
          iprot.skip(ftype)
14207 
      elif fid == 3:
14208 
        if ftype == TType.I64:
14209 
          self.toDate = iprot.readI64();
14210 
        else:
14211 
          iprot.skip(ftype)
14212 
      else:
14213 
        iprot.skip(ftype)
14214 
      iprot.readFieldEnd()
14215 
    iprot.readStructEnd()
14216 
 
14217 
  def write(self, oprot):
14218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14220 
      return
14221 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14222 
    if self.warehouseId is not None:
2690 chandransh 14223 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14224 
      oprot.writeI64(self.warehouseId)
14225 
      oprot.writeFieldEnd()
3431 rajveer 14226 
    if self.fromDate is not None:
2690 chandransh 14227 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14228 
      oprot.writeI64(self.fromDate)
14229 
      oprot.writeFieldEnd()
3431 rajveer 14230 
    if self.toDate is not None:
2690 chandransh 14231 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14232 
      oprot.writeI64(self.toDate)
14233 
      oprot.writeFieldEnd()
14234 
    oprot.writeFieldStop()
14235 
    oprot.writeStructEnd()
14236 
 
3431 rajveer 14237 
  def validate(self):
14238 
    return
14239 
 
14240 
 
2690 chandransh 14241 
  def __repr__(self):
14242 
    L = ['%s=%r' % (key, value)
14243 
      for key, value in self.__dict__.iteritems()]
14244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14245 
 
14246 
  def __eq__(self, other):
14247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14248 
 
14249 
  def __ne__(self, other):
14250 
    return not (self == other)
14251 
 
14252 
class getReturnOrders_result:
14253 
  """
14254 
  Attributes:
14255 
   - success
14256 
  """
14257 
 
14258 
  thrift_spec = (
14259 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14260 
  )
14261 
 
14262 
  def __init__(self, success=None,):
14263 
    self.success = success
14264 
 
14265 
  def read(self, iprot):
14266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14268 
      return
14269 
    iprot.readStructBegin()
14270 
    while True:
14271 
      (fname, ftype, fid) = iprot.readFieldBegin()
14272 
      if ftype == TType.STOP:
14273 
        break
14274 
      if fid == 0:
14275 
        if ftype == TType.LIST:
14276 
          self.success = []
4783 phani.kuma 14277 
          (_etype239, _size236) = iprot.readListBegin()
14278 
          for _i240 in xrange(_size236):
14279 
            _elem241 = ReturnOrder()
14280 
            _elem241.read(iprot)
14281 
            self.success.append(_elem241)
2690 chandransh 14282 
          iprot.readListEnd()
14283 
        else:
14284 
          iprot.skip(ftype)
14285 
      else:
14286 
        iprot.skip(ftype)
14287 
      iprot.readFieldEnd()
14288 
    iprot.readStructEnd()
14289 
 
14290 
  def write(self, oprot):
14291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14293 
      return
14294 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14295 
    if self.success is not None:
2690 chandransh 14296 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14297 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 14298 
      for iter242 in self.success:
14299 
        iter242.write(oprot)
2690 chandransh 14300 
      oprot.writeListEnd()
14301 
      oprot.writeFieldEnd()
14302 
    oprot.writeFieldStop()
14303 
    oprot.writeStructEnd()
14304 
 
3431 rajveer 14305 
  def validate(self):
14306 
    return
14307 
 
14308 
 
2690 chandransh 14309 
  def __repr__(self):
14310 
    L = ['%s=%r' % (key, value)
14311 
      for key, value in self.__dict__.iteritems()]
14312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14313 
 
14314 
  def __eq__(self, other):
14315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14316 
 
14317 
  def __ne__(self, other):
14318 
    return not (self == other)
14319 
 
2700 chandransh 14320 
class getReturnOrder_args:
14321 
  """
14322 
  Attributes:
14323 
   - id
14324 
  """
14325 
 
14326 
  thrift_spec = (
14327 
    None, # 0
14328 
    (1, TType.I64, 'id', None, None, ), # 1
14329 
  )
14330 
 
14331 
  def __init__(self, id=None,):
14332 
    self.id = id
14333 
 
14334 
  def read(self, iprot):
14335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14337 
      return
14338 
    iprot.readStructBegin()
14339 
    while True:
14340 
      (fname, ftype, fid) = iprot.readFieldBegin()
14341 
      if ftype == TType.STOP:
14342 
        break
14343 
      if fid == 1:
14344 
        if ftype == TType.I64:
14345 
          self.id = iprot.readI64();
14346 
        else:
14347 
          iprot.skip(ftype)
14348 
      else:
14349 
        iprot.skip(ftype)
14350 
      iprot.readFieldEnd()
14351 
    iprot.readStructEnd()
14352 
 
14353 
  def write(self, oprot):
14354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14356 
      return
14357 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14358 
    if self.id is not None:
2700 chandransh 14359 
      oprot.writeFieldBegin('id', TType.I64, 1)
14360 
      oprot.writeI64(self.id)
14361 
      oprot.writeFieldEnd()
14362 
    oprot.writeFieldStop()
14363 
    oprot.writeStructEnd()
14364 
 
3431 rajveer 14365 
  def validate(self):
14366 
    return
14367 
 
14368 
 
2700 chandransh 14369 
  def __repr__(self):
14370 
    L = ['%s=%r' % (key, value)
14371 
      for key, value in self.__dict__.iteritems()]
14372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14373 
 
14374 
  def __eq__(self, other):
14375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14376 
 
14377 
  def __ne__(self, other):
14378 
    return not (self == other)
14379 
 
14380 
class getReturnOrder_result:
14381 
  """
14382 
  Attributes:
14383 
   - success
14384 
   - ex
14385 
  """
14386 
 
14387 
  thrift_spec = (
14388 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14389 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14390 
  )
14391 
 
14392 
  def __init__(self, success=None, ex=None,):
14393 
    self.success = success
14394 
    self.ex = ex
14395 
 
14396 
  def read(self, iprot):
14397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14399 
      return
14400 
    iprot.readStructBegin()
14401 
    while True:
14402 
      (fname, ftype, fid) = iprot.readFieldBegin()
14403 
      if ftype == TType.STOP:
14404 
        break
14405 
      if fid == 0:
14406 
        if ftype == TType.STRUCT:
14407 
          self.success = ReturnOrder()
14408 
          self.success.read(iprot)
14409 
        else:
14410 
          iprot.skip(ftype)
14411 
      elif fid == 1:
14412 
        if ftype == TType.STRUCT:
14413 
          self.ex = TransactionServiceException()
14414 
          self.ex.read(iprot)
14415 
        else:
14416 
          iprot.skip(ftype)
14417 
      else:
14418 
        iprot.skip(ftype)
14419 
      iprot.readFieldEnd()
14420 
    iprot.readStructEnd()
14421 
 
14422 
  def write(self, oprot):
14423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14425 
      return
14426 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14427 
    if self.success is not None:
2700 chandransh 14428 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14429 
      self.success.write(oprot)
14430 
      oprot.writeFieldEnd()
3431 rajveer 14431 
    if self.ex is not None:
2700 chandransh 14432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14433 
      self.ex.write(oprot)
14434 
      oprot.writeFieldEnd()
14435 
    oprot.writeFieldStop()
14436 
    oprot.writeStructEnd()
14437 
 
3431 rajveer 14438 
  def validate(self):
14439 
    return
14440 
 
14441 
 
2700 chandransh 14442 
  def __repr__(self):
14443 
    L = ['%s=%r' % (key, value)
14444 
      for key, value in self.__dict__.iteritems()]
14445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14446 
 
14447 
  def __eq__(self, other):
14448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14449 
 
14450 
  def __ne__(self, other):
14451 
    return not (self == other)
14452 
 
2690 chandransh 14453 
class processReturn_args:
14454 
  """
14455 
  Attributes:
14456 
   - returnOrderId
14457 
  """
14458 
 
14459 
  thrift_spec = (
14460 
    None, # 0
14461 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14462 
  )
14463 
 
14464 
  def __init__(self, returnOrderId=None,):
14465 
    self.returnOrderId = returnOrderId
14466 
 
14467 
  def read(self, iprot):
14468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14470 
      return
14471 
    iprot.readStructBegin()
14472 
    while True:
14473 
      (fname, ftype, fid) = iprot.readFieldBegin()
14474 
      if ftype == TType.STOP:
14475 
        break
14476 
      if fid == 1:
14477 
        if ftype == TType.I64:
14478 
          self.returnOrderId = iprot.readI64();
14479 
        else:
14480 
          iprot.skip(ftype)
14481 
      else:
14482 
        iprot.skip(ftype)
14483 
      iprot.readFieldEnd()
14484 
    iprot.readStructEnd()
14485 
 
14486 
  def write(self, oprot):
14487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14489 
      return
14490 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14491 
    if self.returnOrderId is not None:
2690 chandransh 14492 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14493 
      oprot.writeI64(self.returnOrderId)
14494 
      oprot.writeFieldEnd()
14495 
    oprot.writeFieldStop()
14496 
    oprot.writeStructEnd()
14497 
 
3431 rajveer 14498 
  def validate(self):
14499 
    return
14500 
 
14501 
 
2690 chandransh 14502 
  def __repr__(self):
14503 
    L = ['%s=%r' % (key, value)
14504 
      for key, value in self.__dict__.iteritems()]
14505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14506 
 
14507 
  def __eq__(self, other):
14508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14509 
 
14510 
  def __ne__(self, other):
14511 
    return not (self == other)
14512 
 
14513 
class processReturn_result:
14514 
  """
14515 
  Attributes:
14516 
   - ex
14517 
  """
14518 
 
14519 
  thrift_spec = (
14520 
    None, # 0
14521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14522 
  )
14523 
 
14524 
  def __init__(self, ex=None,):
14525 
    self.ex = ex
14526 
 
14527 
  def read(self, iprot):
14528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14530 
      return
14531 
    iprot.readStructBegin()
14532 
    while True:
14533 
      (fname, ftype, fid) = iprot.readFieldBegin()
14534 
      if ftype == TType.STOP:
14535 
        break
14536 
      if fid == 1:
14537 
        if ftype == TType.STRUCT:
14538 
          self.ex = TransactionServiceException()
14539 
          self.ex.read(iprot)
14540 
        else:
14541 
          iprot.skip(ftype)
14542 
      else:
14543 
        iprot.skip(ftype)
14544 
      iprot.readFieldEnd()
14545 
    iprot.readStructEnd()
14546 
 
14547 
  def write(self, oprot):
14548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14550 
      return
14551 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14552 
    if self.ex is not None:
2690 chandransh 14553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14554 
      self.ex.write(oprot)
14555 
      oprot.writeFieldEnd()
14556 
    oprot.writeFieldStop()
14557 
    oprot.writeStructEnd()
14558 
 
3431 rajveer 14559 
  def validate(self):
14560 
    return
14561 
 
14562 
 
2690 chandransh 14563 
  def __repr__(self):
14564 
    L = ['%s=%r' % (key, value)
14565 
      for key, value in self.__dict__.iteritems()]
14566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14567 
 
14568 
  def __eq__(self, other):
14569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14570 
 
14571 
  def __ne__(self, other):
14572 
    return not (self == other)
14573 
 
3451 chandransh 14574 
class updateWeight_args:
14575 
  """
14576 
  Attributes:
14577 
   - orderId
14578 
   - weight
14579 
  """
14580 
 
14581 
  thrift_spec = (
14582 
    None, # 0
14583 
    (1, TType.I64, 'orderId', None, None, ), # 1
14584 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14585 
  )
14586 
 
14587 
  def __init__(self, orderId=None, weight=None,):
14588 
    self.orderId = orderId
14589 
    self.weight = weight
14590 
 
14591 
  def read(self, iprot):
14592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14594 
      return
14595 
    iprot.readStructBegin()
14596 
    while True:
14597 
      (fname, ftype, fid) = iprot.readFieldBegin()
14598 
      if ftype == TType.STOP:
14599 
        break
14600 
      if fid == 1:
14601 
        if ftype == TType.I64:
14602 
          self.orderId = iprot.readI64();
14603 
        else:
14604 
          iprot.skip(ftype)
14605 
      elif fid == 2:
14606 
        if ftype == TType.DOUBLE:
14607 
          self.weight = iprot.readDouble();
14608 
        else:
14609 
          iprot.skip(ftype)
14610 
      else:
14611 
        iprot.skip(ftype)
14612 
      iprot.readFieldEnd()
14613 
    iprot.readStructEnd()
14614 
 
14615 
  def write(self, oprot):
14616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14618 
      return
14619 
    oprot.writeStructBegin('updateWeight_args')
14620 
    if self.orderId is not None:
14621 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14622 
      oprot.writeI64(self.orderId)
14623 
      oprot.writeFieldEnd()
14624 
    if self.weight is not None:
14625 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14626 
      oprot.writeDouble(self.weight)
14627 
      oprot.writeFieldEnd()
14628 
    oprot.writeFieldStop()
14629 
    oprot.writeStructEnd()
14630 
 
14631 
  def validate(self):
14632 
    return
14633 
 
14634 
 
14635 
  def __repr__(self):
14636 
    L = ['%s=%r' % (key, value)
14637 
      for key, value in self.__dict__.iteritems()]
14638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14639 
 
14640 
  def __eq__(self, other):
14641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14642 
 
14643 
  def __ne__(self, other):
14644 
    return not (self == other)
14645 
 
14646 
class updateWeight_result:
14647 
  """
14648 
  Attributes:
14649 
   - success
14650 
   - ex
14651 
  """
14652 
 
14653 
  thrift_spec = (
14654 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14656 
  )
14657 
 
14658 
  def __init__(self, success=None, ex=None,):
14659 
    self.success = success
14660 
    self.ex = ex
14661 
 
14662 
  def read(self, iprot):
14663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14665 
      return
14666 
    iprot.readStructBegin()
14667 
    while True:
14668 
      (fname, ftype, fid) = iprot.readFieldBegin()
14669 
      if ftype == TType.STOP:
14670 
        break
14671 
      if fid == 0:
14672 
        if ftype == TType.STRUCT:
14673 
          self.success = Order()
14674 
          self.success.read(iprot)
14675 
        else:
14676 
          iprot.skip(ftype)
14677 
      elif fid == 1:
14678 
        if ftype == TType.STRUCT:
14679 
          self.ex = TransactionServiceException()
14680 
          self.ex.read(iprot)
14681 
        else:
14682 
          iprot.skip(ftype)
14683 
      else:
14684 
        iprot.skip(ftype)
14685 
      iprot.readFieldEnd()
14686 
    iprot.readStructEnd()
14687 
 
14688 
  def write(self, oprot):
14689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14691 
      return
14692 
    oprot.writeStructBegin('updateWeight_result')
14693 
    if self.success is not None:
14694 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14695 
      self.success.write(oprot)
14696 
      oprot.writeFieldEnd()
14697 
    if self.ex is not None:
14698 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14699 
      self.ex.write(oprot)
14700 
      oprot.writeFieldEnd()
14701 
    oprot.writeFieldStop()
14702 
    oprot.writeStructEnd()
14703 
 
14704 
  def validate(self):
14705 
    return
14706 
 
14707 
 
14708 
  def __repr__(self):
14709 
    L = ['%s=%r' % (key, value)
14710 
      for key, value in self.__dict__.iteritems()]
14711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14712 
 
14713 
  def __eq__(self, other):
14714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14715 
 
14716 
  def __ne__(self, other):
14717 
    return not (self == other)
3469 chandransh 14718 
 
14719 
class changeItem_args:
14720 
  """
14721 
  Attributes:
14722 
   - orderId
14723 
   - itemId
14724 
  """
14725 
 
14726 
  thrift_spec = (
14727 
    None, # 0
14728 
    (1, TType.I64, 'orderId', None, None, ), # 1
14729 
    (2, TType.I64, 'itemId', None, None, ), # 2
14730 
  )
14731 
 
14732 
  def __init__(self, orderId=None, itemId=None,):
14733 
    self.orderId = orderId
14734 
    self.itemId = itemId
14735 
 
14736 
  def read(self, iprot):
14737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14739 
      return
14740 
    iprot.readStructBegin()
14741 
    while True:
14742 
      (fname, ftype, fid) = iprot.readFieldBegin()
14743 
      if ftype == TType.STOP:
14744 
        break
14745 
      if fid == 1:
14746 
        if ftype == TType.I64:
14747 
          self.orderId = iprot.readI64();
14748 
        else:
14749 
          iprot.skip(ftype)
14750 
      elif fid == 2:
14751 
        if ftype == TType.I64:
14752 
          self.itemId = iprot.readI64();
14753 
        else:
14754 
          iprot.skip(ftype)
14755 
      else:
14756 
        iprot.skip(ftype)
14757 
      iprot.readFieldEnd()
14758 
    iprot.readStructEnd()
14759 
 
14760 
  def write(self, oprot):
14761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14763 
      return
14764 
    oprot.writeStructBegin('changeItem_args')
14765 
    if self.orderId is not None:
14766 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14767 
      oprot.writeI64(self.orderId)
14768 
      oprot.writeFieldEnd()
14769 
    if self.itemId is not None:
14770 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14771 
      oprot.writeI64(self.itemId)
14772 
      oprot.writeFieldEnd()
14773 
    oprot.writeFieldStop()
14774 
    oprot.writeStructEnd()
14775 
 
14776 
  def validate(self):
14777 
    return
14778 
 
14779 
 
14780 
  def __repr__(self):
14781 
    L = ['%s=%r' % (key, value)
14782 
      for key, value in self.__dict__.iteritems()]
14783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14784 
 
14785 
  def __eq__(self, other):
14786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14787 
 
14788 
  def __ne__(self, other):
14789 
    return not (self == other)
14790 
 
14791 
class changeItem_result:
14792 
  """
14793 
  Attributes:
14794 
   - success
14795 
   - ex
14796 
  """
14797 
 
14798 
  thrift_spec = (
14799 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14801 
  )
14802 
 
14803 
  def __init__(self, success=None, ex=None,):
14804 
    self.success = success
14805 
    self.ex = ex
14806 
 
14807 
  def read(self, iprot):
14808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14810 
      return
14811 
    iprot.readStructBegin()
14812 
    while True:
14813 
      (fname, ftype, fid) = iprot.readFieldBegin()
14814 
      if ftype == TType.STOP:
14815 
        break
14816 
      if fid == 0:
14817 
        if ftype == TType.STRUCT:
14818 
          self.success = Order()
14819 
          self.success.read(iprot)
14820 
        else:
14821 
          iprot.skip(ftype)
14822 
      elif fid == 1:
14823 
        if ftype == TType.STRUCT:
14824 
          self.ex = TransactionServiceException()
14825 
          self.ex.read(iprot)
14826 
        else:
14827 
          iprot.skip(ftype)
14828 
      else:
14829 
        iprot.skip(ftype)
14830 
      iprot.readFieldEnd()
14831 
    iprot.readStructEnd()
14832 
 
14833 
  def write(self, oprot):
14834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14836 
      return
14837 
    oprot.writeStructBegin('changeItem_result')
14838 
    if self.success is not None:
14839 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14840 
      self.success.write(oprot)
14841 
      oprot.writeFieldEnd()
14842 
    if self.ex is not None:
14843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14844 
      self.ex.write(oprot)
14845 
      oprot.writeFieldEnd()
14846 
    oprot.writeFieldStop()
14847 
    oprot.writeStructEnd()
14848 
 
14849 
  def validate(self):
14850 
    return
14851 
 
14852 
 
14853 
  def __repr__(self):
14854 
    L = ['%s=%r' % (key, value)
14855 
      for key, value in self.__dict__.iteritems()]
14856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14857 
 
14858 
  def __eq__(self, other):
14859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14860 
 
14861 
  def __ne__(self, other):
14862 
    return not (self == other)
14863 
 
14864 
class shiftToWarehouse_args:
14865 
  """
14866 
  Attributes:
14867 
   - orderId
14868 
   - warehouseId
14869 
  """
14870 
 
14871 
  thrift_spec = (
14872 
    None, # 0
14873 
    (1, TType.I64, 'orderId', None, None, ), # 1
14874 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14875 
  )
14876 
 
14877 
  def __init__(self, orderId=None, warehouseId=None,):
14878 
    self.orderId = orderId
14879 
    self.warehouseId = warehouseId
14880 
 
14881 
  def read(self, iprot):
14882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14884 
      return
14885 
    iprot.readStructBegin()
14886 
    while True:
14887 
      (fname, ftype, fid) = iprot.readFieldBegin()
14888 
      if ftype == TType.STOP:
14889 
        break
14890 
      if fid == 1:
14891 
        if ftype == TType.I64:
14892 
          self.orderId = iprot.readI64();
14893 
        else:
14894 
          iprot.skip(ftype)
14895 
      elif fid == 2:
14896 
        if ftype == TType.I64:
14897 
          self.warehouseId = iprot.readI64();
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      else:
14901 
        iprot.skip(ftype)
14902 
      iprot.readFieldEnd()
14903 
    iprot.readStructEnd()
14904 
 
14905 
  def write(self, oprot):
14906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14908 
      return
14909 
    oprot.writeStructBegin('shiftToWarehouse_args')
14910 
    if self.orderId is not None:
14911 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14912 
      oprot.writeI64(self.orderId)
14913 
      oprot.writeFieldEnd()
14914 
    if self.warehouseId is not None:
14915 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14916 
      oprot.writeI64(self.warehouseId)
14917 
      oprot.writeFieldEnd()
14918 
    oprot.writeFieldStop()
14919 
    oprot.writeStructEnd()
14920 
 
14921 
  def validate(self):
14922 
    return
14923 
 
14924 
 
14925 
  def __repr__(self):
14926 
    L = ['%s=%r' % (key, value)
14927 
      for key, value in self.__dict__.iteritems()]
14928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14929 
 
14930 
  def __eq__(self, other):
14931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14932 
 
14933 
  def __ne__(self, other):
14934 
    return not (self == other)
14935 
 
14936 
class shiftToWarehouse_result:
14937 
  """
14938 
  Attributes:
14939 
   - success
14940 
   - ex
14941 
  """
14942 
 
14943 
  thrift_spec = (
14944 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14946 
  )
14947 
 
14948 
  def __init__(self, success=None, ex=None,):
14949 
    self.success = success
14950 
    self.ex = ex
14951 
 
14952 
  def read(self, iprot):
14953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14955 
      return
14956 
    iprot.readStructBegin()
14957 
    while True:
14958 
      (fname, ftype, fid) = iprot.readFieldBegin()
14959 
      if ftype == TType.STOP:
14960 
        break
14961 
      if fid == 0:
14962 
        if ftype == TType.STRUCT:
14963 
          self.success = Order()
14964 
          self.success.read(iprot)
14965 
        else:
14966 
          iprot.skip(ftype)
14967 
      elif fid == 1:
14968 
        if ftype == TType.STRUCT:
14969 
          self.ex = TransactionServiceException()
14970 
          self.ex.read(iprot)
14971 
        else:
14972 
          iprot.skip(ftype)
14973 
      else:
14974 
        iprot.skip(ftype)
14975 
      iprot.readFieldEnd()
14976 
    iprot.readStructEnd()
14977 
 
14978 
  def write(self, oprot):
14979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14981 
      return
14982 
    oprot.writeStructBegin('shiftToWarehouse_result')
14983 
    if self.success is not None:
14984 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14985 
      self.success.write(oprot)
14986 
      oprot.writeFieldEnd()
14987 
    if self.ex is not None:
14988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14989 
      self.ex.write(oprot)
14990 
      oprot.writeFieldEnd()
14991 
    oprot.writeFieldStop()
14992 
    oprot.writeStructEnd()
14993 
 
14994 
  def validate(self):
14995 
    return
14996 
 
14997 
 
14998 
  def __repr__(self):
14999 
    L = ['%s=%r' % (key, value)
15000 
      for key, value in self.__dict__.iteritems()]
15001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15002 
 
15003 
  def __eq__(self, other):
15004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15005 
 
15006 
  def __ne__(self, other):
15007 
    return not (self == other)
3553 chandransh 15008 
 
15009 
class addDelayReason_args:
15010 
  """
15011 
  Attributes:
15012 
   - orderId
15013 
   - delayReason
3986 chandransh 15014 
   - furtherDelay
4647 rajveer 15015 
   - delayReasonText
3553 chandransh 15016 
  """
15017 
 
15018 
  thrift_spec = (
15019 
    None, # 0
15020 
    (1, TType.I64, 'orderId', None, None, ), # 1
15021 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 15022 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 15023 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 15024 
  )
15025 
 
4647 rajveer 15026 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 15027 
    self.orderId = orderId
15028 
    self.delayReason = delayReason
3986 chandransh 15029 
    self.furtherDelay = furtherDelay
4647 rajveer 15030 
    self.delayReasonText = delayReasonText
3553 chandransh 15031 
 
15032 
  def read(self, iprot):
15033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15035 
      return
15036 
    iprot.readStructBegin()
15037 
    while True:
15038 
      (fname, ftype, fid) = iprot.readFieldBegin()
15039 
      if ftype == TType.STOP:
15040 
        break
15041 
      if fid == 1:
15042 
        if ftype == TType.I64:
15043 
          self.orderId = iprot.readI64();
15044 
        else:
15045 
          iprot.skip(ftype)
15046 
      elif fid == 2:
15047 
        if ftype == TType.I32:
15048 
          self.delayReason = iprot.readI32();
15049 
        else:
15050 
          iprot.skip(ftype)
3986 chandransh 15051 
      elif fid == 3:
15052 
        if ftype == TType.I64:
15053 
          self.furtherDelay = iprot.readI64();
15054 
        else:
15055 
          iprot.skip(ftype)
4647 rajveer 15056 
      elif fid == 4:
15057 
        if ftype == TType.STRING:
15058 
          self.delayReasonText = iprot.readString();
15059 
        else:
15060 
          iprot.skip(ftype)
3553 chandransh 15061 
      else:
15062 
        iprot.skip(ftype)
15063 
      iprot.readFieldEnd()
15064 
    iprot.readStructEnd()
15065 
 
15066 
  def write(self, oprot):
15067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15069 
      return
15070 
    oprot.writeStructBegin('addDelayReason_args')
15071 
    if self.orderId is not None:
15072 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15073 
      oprot.writeI64(self.orderId)
15074 
      oprot.writeFieldEnd()
15075 
    if self.delayReason is not None:
15076 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15077 
      oprot.writeI32(self.delayReason)
15078 
      oprot.writeFieldEnd()
3986 chandransh 15079 
    if self.furtherDelay is not None:
15080 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15081 
      oprot.writeI64(self.furtherDelay)
15082 
      oprot.writeFieldEnd()
4647 rajveer 15083 
    if self.delayReasonText is not None:
15084 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15085 
      oprot.writeString(self.delayReasonText)
15086 
      oprot.writeFieldEnd()
3553 chandransh 15087 
    oprot.writeFieldStop()
15088 
    oprot.writeStructEnd()
15089 
 
15090 
  def validate(self):
15091 
    return
15092 
 
15093 
 
15094 
  def __repr__(self):
15095 
    L = ['%s=%r' % (key, value)
15096 
      for key, value in self.__dict__.iteritems()]
15097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15098 
 
15099 
  def __eq__(self, other):
15100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15101 
 
15102 
  def __ne__(self, other):
15103 
    return not (self == other)
15104 
 
15105 
class addDelayReason_result:
15106 
  """
15107 
  Attributes:
15108 
   - success
15109 
   - ex
15110 
  """
15111 
 
15112 
  thrift_spec = (
15113 
    (0, TType.BOOL, 'success', None, None, ), # 0
15114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15115 
  )
15116 
 
15117 
  def __init__(self, success=None, ex=None,):
15118 
    self.success = success
15119 
    self.ex = ex
15120 
 
15121 
  def read(self, iprot):
15122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15124 
      return
15125 
    iprot.readStructBegin()
15126 
    while True:
15127 
      (fname, ftype, fid) = iprot.readFieldBegin()
15128 
      if ftype == TType.STOP:
15129 
        break
15130 
      if fid == 0:
15131 
        if ftype == TType.BOOL:
15132 
          self.success = iprot.readBool();
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      elif fid == 1:
15136 
        if ftype == TType.STRUCT:
15137 
          self.ex = TransactionServiceException()
15138 
          self.ex.read(iprot)
15139 
        else:
15140 
          iprot.skip(ftype)
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('addDelayReason_result')
15151 
    if self.success is not None:
15152 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15153 
      oprot.writeBool(self.success)
15154 
      oprot.writeFieldEnd()
15155 
    if self.ex is not None:
15156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15157 
      self.ex.write(oprot)
15158 
      oprot.writeFieldEnd()
15159 
    oprot.writeFieldStop()
15160 
    oprot.writeStructEnd()
15161 
 
15162 
  def validate(self):
15163 
    return
15164 
 
15165 
 
15166 
  def __repr__(self):
15167 
    L = ['%s=%r' % (key, value)
15168 
      for key, value in self.__dict__.iteritems()]
15169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15170 
 
15171 
  def __eq__(self, other):
15172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15173 
 
15174 
  def __ne__(self, other):
15175 
    return not (self == other)
3956 chandransh 15176 
 
15177 
class reconcileCodCollection_args:
15178 
  """
15179 
  Attributes:
15180 
   - collectedAmountMap
15181 
   - xferBy
15182 
   - xferTxnId
15183 
   - xferDate
15184 
  """
15185 
 
15186 
  thrift_spec = (
15187 
    None, # 0
15188 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15189 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15190 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15191 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15192 
  )
15193 
 
15194 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15195 
    self.collectedAmountMap = collectedAmountMap
15196 
    self.xferBy = xferBy
15197 
    self.xferTxnId = xferTxnId
15198 
    self.xferDate = xferDate
15199 
 
15200 
  def read(self, iprot):
15201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15203 
      return
15204 
    iprot.readStructBegin()
15205 
    while True:
15206 
      (fname, ftype, fid) = iprot.readFieldBegin()
15207 
      if ftype == TType.STOP:
15208 
        break
15209 
      if fid == 1:
15210 
        if ftype == TType.MAP:
15211 
          self.collectedAmountMap = {}
4783 phani.kuma 15212 
          (_ktype244, _vtype245, _size243 ) = iprot.readMapBegin()
15213 
          for _i247 in xrange(_size243):
15214 
            _key248 = iprot.readString();
15215 
            _val249 = iprot.readDouble();
15216 
            self.collectedAmountMap[_key248] = _val249
3956 chandransh 15217 
          iprot.readMapEnd()
15218 
        else:
15219 
          iprot.skip(ftype)
15220 
      elif fid == 2:
15221 
        if ftype == TType.STRING:
15222 
          self.xferBy = iprot.readString();
15223 
        else:
15224 
          iprot.skip(ftype)
15225 
      elif fid == 3:
15226 
        if ftype == TType.STRING:
15227 
          self.xferTxnId = iprot.readString();
15228 
        else:
15229 
          iprot.skip(ftype)
15230 
      elif fid == 4:
15231 
        if ftype == TType.I64:
15232 
          self.xferDate = iprot.readI64();
15233 
        else:
15234 
          iprot.skip(ftype)
15235 
      else:
15236 
        iprot.skip(ftype)
15237 
      iprot.readFieldEnd()
15238 
    iprot.readStructEnd()
15239 
 
15240 
  def write(self, oprot):
15241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15243 
      return
15244 
    oprot.writeStructBegin('reconcileCodCollection_args')
15245 
    if self.collectedAmountMap is not None:
15246 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15247 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4783 phani.kuma 15248 
      for kiter250,viter251 in self.collectedAmountMap.items():
15249 
        oprot.writeString(kiter250)
15250 
        oprot.writeDouble(viter251)
3956 chandransh 15251 
      oprot.writeMapEnd()
15252 
      oprot.writeFieldEnd()
15253 
    if self.xferBy is not None:
15254 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15255 
      oprot.writeString(self.xferBy)
15256 
      oprot.writeFieldEnd()
15257 
    if self.xferTxnId is not None:
15258 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15259 
      oprot.writeString(self.xferTxnId)
15260 
      oprot.writeFieldEnd()
15261 
    if self.xferDate is not None:
15262 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15263 
      oprot.writeI64(self.xferDate)
15264 
      oprot.writeFieldEnd()
15265 
    oprot.writeFieldStop()
15266 
    oprot.writeStructEnd()
15267 
 
15268 
  def validate(self):
15269 
    return
15270 
 
15271 
 
15272 
  def __repr__(self):
15273 
    L = ['%s=%r' % (key, value)
15274 
      for key, value in self.__dict__.iteritems()]
15275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15276 
 
15277 
  def __eq__(self, other):
15278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15279 
 
15280 
  def __ne__(self, other):
15281 
    return not (self == other)
15282 
 
15283 
class reconcileCodCollection_result:
15284 
  """
15285 
  Attributes:
15286 
   - success
15287 
   - ex
15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15293 
  )
15294 
 
15295 
  def __init__(self, success=None, ex=None,):
15296 
    self.success = success
15297 
    self.ex = ex
15298 
 
15299 
  def read(self, iprot):
15300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15302 
      return
15303 
    iprot.readStructBegin()
15304 
    while True:
15305 
      (fname, ftype, fid) = iprot.readFieldBegin()
15306 
      if ftype == TType.STOP:
15307 
        break
15308 
      if fid == 0:
15309 
        if ftype == TType.MAP:
15310 
          self.success = {}
4783 phani.kuma 15311 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15312 
          for _i256 in xrange(_size252):
15313 
            _key257 = iprot.readString();
15314 
            _val258 = iprot.readString();
15315 
            self.success[_key257] = _val258
3956 chandransh 15316 
          iprot.readMapEnd()
15317 
        else:
15318 
          iprot.skip(ftype)
15319 
      elif fid == 1:
15320 
        if ftype == TType.STRUCT:
15321 
          self.ex = TransactionServiceException()
15322 
          self.ex.read(iprot)
15323 
        else:
15324 
          iprot.skip(ftype)
15325 
      else:
15326 
        iprot.skip(ftype)
15327 
      iprot.readFieldEnd()
15328 
    iprot.readStructEnd()
15329 
 
15330 
  def write(self, oprot):
15331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15333 
      return
15334 
    oprot.writeStructBegin('reconcileCodCollection_result')
15335 
    if self.success is not None:
15336 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15337 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4783 phani.kuma 15338 
      for kiter259,viter260 in self.success.items():
15339 
        oprot.writeString(kiter259)
15340 
        oprot.writeString(viter260)
3956 chandransh 15341 
      oprot.writeMapEnd()
15342 
      oprot.writeFieldEnd()
15343 
    if self.ex is not None:
15344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15345 
      self.ex.write(oprot)
15346 
      oprot.writeFieldEnd()
15347 
    oprot.writeFieldStop()
15348 
    oprot.writeStructEnd()
15349 
 
15350 
  def validate(self):
15351 
    return
15352 
 
15353 
 
15354 
  def __repr__(self):
15355 
    L = ['%s=%r' % (key, value)
15356 
      for key, value in self.__dict__.iteritems()]
15357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15358 
 
15359 
  def __eq__(self, other):
15360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15361 
 
15362 
  def __ne__(self, other):
15363 
    return not (self == other)
4008 mandeep.dh 15364 
 
15365 
class getTransactionsRequiringExtraProcessing_args:
15366 
  """
15367 
  Attributes:
15368 
   - category
15369 
  """
15370 
 
15371 
  thrift_spec = (
15372 
    None, # 0
15373 
    (1, TType.I32, 'category', None, None, ), # 1
15374 
  )
15375 
 
15376 
  def __init__(self, category=None,):
15377 
    self.category = category
15378 
 
15379 
  def read(self, iprot):
15380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15382 
      return
15383 
    iprot.readStructBegin()
15384 
    while True:
15385 
      (fname, ftype, fid) = iprot.readFieldBegin()
15386 
      if ftype == TType.STOP:
15387 
        break
15388 
      if fid == 1:
15389 
        if ftype == TType.I32:
15390 
          self.category = iprot.readI32();
15391 
        else:
15392 
          iprot.skip(ftype)
15393 
      else:
15394 
        iprot.skip(ftype)
15395 
      iprot.readFieldEnd()
15396 
    iprot.readStructEnd()
15397 
 
15398 
  def write(self, oprot):
15399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15401 
      return
15402 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15403 
    if self.category is not None:
15404 
      oprot.writeFieldBegin('category', TType.I32, 1)
15405 
      oprot.writeI32(self.category)
15406 
      oprot.writeFieldEnd()
15407 
    oprot.writeFieldStop()
15408 
    oprot.writeStructEnd()
15409 
 
15410 
  def validate(self):
15411 
    return
15412 
 
15413 
 
15414 
  def __repr__(self):
15415 
    L = ['%s=%r' % (key, value)
15416 
      for key, value in self.__dict__.iteritems()]
15417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15418 
 
15419 
  def __eq__(self, other):
15420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15421 
 
15422 
  def __ne__(self, other):
15423 
    return not (self == other)
15424 
 
15425 
class getTransactionsRequiringExtraProcessing_result:
15426 
  """
15427 
  Attributes:
15428 
   - success
15429 
  """
15430 
 
15431 
  thrift_spec = (
15432 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15433 
  )
15434 
 
15435 
  def __init__(self, success=None,):
15436 
    self.success = success
15437 
 
15438 
  def read(self, iprot):
15439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15441 
      return
15442 
    iprot.readStructBegin()
15443 
    while True:
15444 
      (fname, ftype, fid) = iprot.readFieldBegin()
15445 
      if ftype == TType.STOP:
15446 
        break
15447 
      if fid == 0:
15448 
        if ftype == TType.LIST:
15449 
          self.success = []
4783 phani.kuma 15450 
          (_etype264, _size261) = iprot.readListBegin()
15451 
          for _i265 in xrange(_size261):
15452 
            _elem266 = iprot.readI64();
15453 
            self.success.append(_elem266)
4008 mandeep.dh 15454 
          iprot.readListEnd()
15455 
        else:
15456 
          iprot.skip(ftype)
15457 
      else:
15458 
        iprot.skip(ftype)
15459 
      iprot.readFieldEnd()
15460 
    iprot.readStructEnd()
15461 
 
15462 
  def write(self, oprot):
15463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15465 
      return
15466 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15467 
    if self.success is not None:
15468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15469 
      oprot.writeListBegin(TType.I64, len(self.success))
4783 phani.kuma 15470 
      for iter267 in self.success:
15471 
        oprot.writeI64(iter267)
4008 mandeep.dh 15472 
      oprot.writeListEnd()
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
15491 
 
15492 
class markTransactionAsProcessed_args:
15493 
  """
15494 
  Attributes:
15495 
   - transactionId
15496 
   - category
15497 
  """
15498 
 
15499 
  thrift_spec = (
15500 
    None, # 0
15501 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15502 
    (2, TType.I32, 'category', None, None, ), # 2
15503 
  )
15504 
 
15505 
  def __init__(self, transactionId=None, category=None,):
15506 
    self.transactionId = transactionId
15507 
    self.category = category
15508 
 
15509 
  def read(self, iprot):
15510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15512 
      return
15513 
    iprot.readStructBegin()
15514 
    while True:
15515 
      (fname, ftype, fid) = iprot.readFieldBegin()
15516 
      if ftype == TType.STOP:
15517 
        break
15518 
      if fid == 1:
15519 
        if ftype == TType.I64:
15520 
          self.transactionId = iprot.readI64();
15521 
        else:
15522 
          iprot.skip(ftype)
15523 
      elif fid == 2:
15524 
        if ftype == TType.I32:
15525 
          self.category = iprot.readI32();
15526 
        else:
15527 
          iprot.skip(ftype)
15528 
      else:
15529 
        iprot.skip(ftype)
15530 
      iprot.readFieldEnd()
15531 
    iprot.readStructEnd()
15532 
 
15533 
  def write(self, oprot):
15534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15536 
      return
15537 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15538 
    if self.transactionId is not None:
15539 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15540 
      oprot.writeI64(self.transactionId)
15541 
      oprot.writeFieldEnd()
15542 
    if self.category is not None:
15543 
      oprot.writeFieldBegin('category', TType.I32, 2)
15544 
      oprot.writeI32(self.category)
15545 
      oprot.writeFieldEnd()
15546 
    oprot.writeFieldStop()
15547 
    oprot.writeStructEnd()
15548 
 
15549 
  def validate(self):
15550 
    return
15551 
 
15552 
 
15553 
  def __repr__(self):
15554 
    L = ['%s=%r' % (key, value)
15555 
      for key, value in self.__dict__.iteritems()]
15556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15557 
 
15558 
  def __eq__(self, other):
15559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15560 
 
15561 
  def __ne__(self, other):
15562 
    return not (self == other)
15563 
 
15564 
class markTransactionAsProcessed_result:
15565 
 
15566 
  thrift_spec = (
15567 
  )
15568 
 
15569 
  def read(self, iprot):
15570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15572 
      return
15573 
    iprot.readStructBegin()
15574 
    while True:
15575 
      (fname, ftype, fid) = iprot.readFieldBegin()
15576 
      if ftype == TType.STOP:
15577 
        break
15578 
      else:
15579 
        iprot.skip(ftype)
15580 
      iprot.readFieldEnd()
15581 
    iprot.readStructEnd()
15582 
 
15583 
  def write(self, oprot):
15584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15586 
      return
15587 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15588 
    oprot.writeFieldStop()
15589 
    oprot.writeStructEnd()
15590 
 
15591 
  def validate(self):
15592 
    return
15593 
 
15594 
 
15595 
  def __repr__(self):
15596 
    L = ['%s=%r' % (key, value)
15597 
      for key, value in self.__dict__.iteritems()]
15598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15599 
 
15600 
  def __eq__(self, other):
15601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15602 
 
15603 
  def __ne__(self, other):
15604 
    return not (self == other)
4018 chandransh 15605 
 
15606 
class getItemWiseRiskyOrdersCount_args:
15607 
 
15608 
  thrift_spec = (
15609 
  )
15610 
 
15611 
  def read(self, iprot):
15612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15614 
      return
15615 
    iprot.readStructBegin()
15616 
    while True:
15617 
      (fname, ftype, fid) = iprot.readFieldBegin()
15618 
      if ftype == TType.STOP:
15619 
        break
15620 
      else:
15621 
        iprot.skip(ftype)
15622 
      iprot.readFieldEnd()
15623 
    iprot.readStructEnd()
15624 
 
15625 
  def write(self, oprot):
15626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15628 
      return
15629 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15630 
    oprot.writeFieldStop()
15631 
    oprot.writeStructEnd()
15632 
 
15633 
  def validate(self):
15634 
    return
15635 
 
15636 
 
15637 
  def __repr__(self):
15638 
    L = ['%s=%r' % (key, value)
15639 
      for key, value in self.__dict__.iteritems()]
15640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15641 
 
15642 
  def __eq__(self, other):
15643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15644 
 
15645 
  def __ne__(self, other):
15646 
    return not (self == other)
15647 
 
15648 
class getItemWiseRiskyOrdersCount_result:
15649 
  """
15650 
  Attributes:
15651 
   - success
15652 
  """
15653 
 
15654 
  thrift_spec = (
15655 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15656 
  )
15657 
 
15658 
  def __init__(self, success=None,):
15659 
    self.success = success
15660 
 
15661 
  def read(self, iprot):
15662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15664 
      return
15665 
    iprot.readStructBegin()
15666 
    while True:
15667 
      (fname, ftype, fid) = iprot.readFieldBegin()
15668 
      if ftype == TType.STOP:
15669 
        break
15670 
      if fid == 0:
15671 
        if ftype == TType.MAP:
15672 
          self.success = {}
4783 phani.kuma 15673 
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin()
15674 
          for _i272 in xrange(_size268):
15675 
            _key273 = iprot.readI64();
15676 
            _val274 = iprot.readI64();
15677 
            self.success[_key273] = _val274
4018 chandransh 15678 
          iprot.readMapEnd()
15679 
        else:
15680 
          iprot.skip(ftype)
15681 
      else:
15682 
        iprot.skip(ftype)
15683 
      iprot.readFieldEnd()
15684 
    iprot.readStructEnd()
15685 
 
15686 
  def write(self, oprot):
15687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15689 
      return
15690 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15691 
    if self.success is not None:
15692 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15693 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4783 phani.kuma 15694 
      for kiter275,viter276 in self.success.items():
15695 
        oprot.writeI64(kiter275)
15696 
        oprot.writeI64(viter276)
4018 chandransh 15697 
      oprot.writeMapEnd()
15698 
      oprot.writeFieldEnd()
15699 
    oprot.writeFieldStop()
15700 
    oprot.writeStructEnd()
15701 
 
15702 
  def validate(self):
15703 
    return
15704 
 
15705 
 
15706 
  def __repr__(self):
15707 
    L = ['%s=%r' % (key, value)
15708 
      for key, value in self.__dict__.iteritems()]
15709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15710 
 
15711 
  def __eq__(self, other):
15712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15713 
 
15714 
  def __ne__(self, other):
15715 
    return not (self == other)
4247 rajveer 15716 
 
4295 varun.gupt 15717 
class getOrdersForItemIds_args:
15718 
  """
15719 
  Attributes:
15720 
   - itemIds
15721 
  """
15722 
 
15723 
  thrift_spec = (
15724 
    None, # 0
15725 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15726 
  )
15727 
 
15728 
  def __init__(self, itemIds=None,):
15729 
    self.itemIds = itemIds
15730 
 
15731 
  def read(self, iprot):
15732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15734 
      return
15735 
    iprot.readStructBegin()
15736 
    while True:
15737 
      (fname, ftype, fid) = iprot.readFieldBegin()
15738 
      if ftype == TType.STOP:
15739 
        break
15740 
      if fid == 1:
15741 
        if ftype == TType.LIST:
15742 
          self.itemIds = []
4783 phani.kuma 15743 
          (_etype280, _size277) = iprot.readListBegin()
15744 
          for _i281 in xrange(_size277):
15745 
            _elem282 = iprot.readI64();
15746 
            self.itemIds.append(_elem282)
4295 varun.gupt 15747 
          iprot.readListEnd()
15748 
        else:
15749 
          iprot.skip(ftype)
15750 
      else:
15751 
        iprot.skip(ftype)
15752 
      iprot.readFieldEnd()
15753 
    iprot.readStructEnd()
15754 
 
15755 
  def write(self, oprot):
15756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15758 
      return
15759 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15760 
    if self.itemIds is not None:
15761 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15762 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4783 phani.kuma 15763 
      for iter283 in self.itemIds:
15764 
        oprot.writeI64(iter283)
4295 varun.gupt 15765 
      oprot.writeListEnd()
15766 
      oprot.writeFieldEnd()
15767 
    oprot.writeFieldStop()
15768 
    oprot.writeStructEnd()
15769 
 
15770 
  def validate(self):
15771 
    return
15772 
 
15773 
 
15774 
  def __repr__(self):
15775 
    L = ['%s=%r' % (key, value)
15776 
      for key, value in self.__dict__.iteritems()]
15777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15778 
 
15779 
  def __eq__(self, other):
15780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15781 
 
15782 
  def __ne__(self, other):
15783 
    return not (self == other)
15784 
 
15785 
class getOrdersForItemIds_result:
15786 
  """
15787 
  Attributes:
15788 
   - success
15789 
  """
15790 
 
15791 
  thrift_spec = (
15792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15793 
  )
15794 
 
15795 
  def __init__(self, success=None,):
15796 
    self.success = success
15797 
 
15798 
  def read(self, iprot):
15799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15801 
      return
15802 
    iprot.readStructBegin()
15803 
    while True:
15804 
      (fname, ftype, fid) = iprot.readFieldBegin()
15805 
      if ftype == TType.STOP:
15806 
        break
15807 
      if fid == 0:
15808 
        if ftype == TType.LIST:
15809 
          self.success = []
4783 phani.kuma 15810 
          (_etype287, _size284) = iprot.readListBegin()
15811 
          for _i288 in xrange(_size284):
15812 
            _elem289 = Order()
15813 
            _elem289.read(iprot)
15814 
            self.success.append(_elem289)
4295 varun.gupt 15815 
          iprot.readListEnd()
15816 
        else:
15817 
          iprot.skip(ftype)
15818 
      else:
15819 
        iprot.skip(ftype)
15820 
      iprot.readFieldEnd()
15821 
    iprot.readStructEnd()
15822 
 
15823 
  def write(self, oprot):
15824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15826 
      return
15827 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15828 
    if self.success is not None:
15829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15830 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 15831 
      for iter290 in self.success:
15832 
        iter290.write(oprot)
4295 varun.gupt 15833 
      oprot.writeListEnd()
15834 
      oprot.writeFieldEnd()
15835 
    oprot.writeFieldStop()
15836 
    oprot.writeStructEnd()
15837 
 
15838 
  def validate(self):
15839 
    return
15840 
 
15841 
 
15842 
  def __repr__(self):
15843 
    L = ['%s=%r' % (key, value)
15844 
      for key, value in self.__dict__.iteritems()]
15845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15846 
 
15847 
  def __eq__(self, other):
15848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15849 
 
15850 
  def __ne__(self, other):
15851 
    return not (self == other)
15852 
 
4247 rajveer 15853 
class markOrderCancellationRequestReceived_args:
15854 
  """
15855 
  Attributes:
15856 
   - orderId
15857 
  """
15858 
 
15859 
  thrift_spec = (
15860 
    None, # 0
15861 
    (1, TType.I64, 'orderId', None, None, ), # 1
15862 
  )
15863 
 
15864 
  def __init__(self, orderId=None,):
15865 
    self.orderId = orderId
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 1:
15877 
        if ftype == TType.I64:
15878 
          self.orderId = iprot.readI64();
15879 
        else:
15880 
          iprot.skip(ftype)
15881 
      else:
15882 
        iprot.skip(ftype)
15883 
      iprot.readFieldEnd()
15884 
    iprot.readStructEnd()
15885 
 
15886 
  def write(self, oprot):
15887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15889 
      return
15890 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15891 
    if self.orderId is not None:
15892 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15893 
      oprot.writeI64(self.orderId)
15894 
      oprot.writeFieldEnd()
15895 
    oprot.writeFieldStop()
15896 
    oprot.writeStructEnd()
15897 
 
15898 
  def validate(self):
15899 
    return
15900 
 
15901 
 
15902 
  def __repr__(self):
15903 
    L = ['%s=%r' % (key, value)
15904 
      for key, value in self.__dict__.iteritems()]
15905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15906 
 
15907 
  def __eq__(self, other):
15908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15909 
 
15910 
  def __ne__(self, other):
15911 
    return not (self == other)
15912 
 
15913 
class markOrderCancellationRequestReceived_result:
15914 
  """
15915 
  Attributes:
15916 
   - ex
15917 
  """
15918 
 
15919 
  thrift_spec = (
15920 
    None, # 0
15921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15922 
  )
15923 
 
15924 
  def __init__(self, ex=None,):
15925 
    self.ex = ex
15926 
 
15927 
  def read(self, iprot):
15928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15930 
      return
15931 
    iprot.readStructBegin()
15932 
    while True:
15933 
      (fname, ftype, fid) = iprot.readFieldBegin()
15934 
      if ftype == TType.STOP:
15935 
        break
15936 
      if fid == 1:
15937 
        if ftype == TType.STRUCT:
15938 
          self.ex = TransactionServiceException()
15939 
          self.ex.read(iprot)
15940 
        else:
15941 
          iprot.skip(ftype)
15942 
      else:
15943 
        iprot.skip(ftype)
15944 
      iprot.readFieldEnd()
15945 
    iprot.readStructEnd()
15946 
 
15947 
  def write(self, oprot):
15948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15950 
      return
15951 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15952 
    if self.ex is not None:
15953 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15954 
      self.ex.write(oprot)
15955 
      oprot.writeFieldEnd()
15956 
    oprot.writeFieldStop()
15957 
    oprot.writeStructEnd()
15958 
 
15959 
  def validate(self):
15960 
    return
15961 
 
15962 
 
15963 
  def __repr__(self):
15964 
    L = ['%s=%r' % (key, value)
15965 
      for key, value in self.__dict__.iteritems()]
15966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15967 
 
15968 
  def __eq__(self, other):
15969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15970 
 
15971 
  def __ne__(self, other):
15972 
    return not (self == other)
15973 
 
15974 
class markOrderCancellationRequestConfirmed_args:
15975 
  """
15976 
  Attributes:
15977 
   - orderId
15978 
  """
15979 
 
15980 
  thrift_spec = (
15981 
    None, # 0
15982 
    (1, TType.I64, 'orderId', None, None, ), # 1
15983 
  )
15984 
 
15985 
  def __init__(self, orderId=None,):
15986 
    self.orderId = orderId
15987 
 
15988 
  def read(self, iprot):
15989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15991 
      return
15992 
    iprot.readStructBegin()
15993 
    while True:
15994 
      (fname, ftype, fid) = iprot.readFieldBegin()
15995 
      if ftype == TType.STOP:
15996 
        break
15997 
      if fid == 1:
15998 
        if ftype == TType.I64:
15999 
          self.orderId = iprot.readI64();
16000 
        else:
16001 
          iprot.skip(ftype)
16002 
      else:
16003 
        iprot.skip(ftype)
16004 
      iprot.readFieldEnd()
16005 
    iprot.readStructEnd()
16006 
 
16007 
  def write(self, oprot):
16008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16010 
      return
16011 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
16012 
    if self.orderId is not None:
16013 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16014 
      oprot.writeI64(self.orderId)
16015 
      oprot.writeFieldEnd()
16016 
    oprot.writeFieldStop()
16017 
    oprot.writeStructEnd()
16018 
 
16019 
  def validate(self):
16020 
    return
16021 
 
16022 
 
16023 
  def __repr__(self):
16024 
    L = ['%s=%r' % (key, value)
16025 
      for key, value in self.__dict__.iteritems()]
16026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16027 
 
16028 
  def __eq__(self, other):
16029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16030 
 
16031 
  def __ne__(self, other):
16032 
    return not (self == other)
16033 
 
16034 
class markOrderCancellationRequestConfirmed_result:
16035 
  """
16036 
  Attributes:
16037 
   - ex
16038 
  """
16039 
 
16040 
  thrift_spec = (
16041 
    None, # 0
16042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16043 
  )
16044 
 
16045 
  def __init__(self, ex=None,):
16046 
    self.ex = ex
16047 
 
16048 
  def read(self, iprot):
16049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16051 
      return
16052 
    iprot.readStructBegin()
16053 
    while True:
16054 
      (fname, ftype, fid) = iprot.readFieldBegin()
16055 
      if ftype == TType.STOP:
16056 
        break
16057 
      if fid == 1:
16058 
        if ftype == TType.STRUCT:
16059 
          self.ex = TransactionServiceException()
16060 
          self.ex.read(iprot)
16061 
        else:
16062 
          iprot.skip(ftype)
16063 
      else:
16064 
        iprot.skip(ftype)
16065 
      iprot.readFieldEnd()
16066 
    iprot.readStructEnd()
16067 
 
16068 
  def write(self, oprot):
16069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16071 
      return
16072 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16073 
    if self.ex is not None:
16074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16075 
      self.ex.write(oprot)
16076 
      oprot.writeFieldEnd()
16077 
    oprot.writeFieldStop()
16078 
    oprot.writeStructEnd()
16079 
 
16080 
  def validate(self):
16081 
    return
16082 
 
16083 
 
16084 
  def __repr__(self):
16085 
    L = ['%s=%r' % (key, value)
16086 
      for key, value in self.__dict__.iteritems()]
16087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16088 
 
16089 
  def __eq__(self, other):
16090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16091 
 
16092 
  def __ne__(self, other):
16093 
    return not (self == other)
16094 
 
16095 
class markOrderCancellationRequestDenied_args:
16096 
  """
16097 
  Attributes:
16098 
   - orderId
16099 
  """
16100 
 
16101 
  thrift_spec = (
16102 
    None, # 0
16103 
    (1, TType.I64, 'orderId', None, None, ), # 1
16104 
  )
16105 
 
16106 
  def __init__(self, orderId=None,):
16107 
    self.orderId = orderId
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      if fid == 1:
16119 
        if ftype == TType.I64:
16120 
          self.orderId = iprot.readI64();
16121 
        else:
16122 
          iprot.skip(ftype)
16123 
      else:
16124 
        iprot.skip(ftype)
16125 
      iprot.readFieldEnd()
16126 
    iprot.readStructEnd()
16127 
 
16128 
  def write(self, oprot):
16129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16131 
      return
16132 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16133 
    if self.orderId is not None:
16134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16135 
      oprot.writeI64(self.orderId)
16136 
      oprot.writeFieldEnd()
16137 
    oprot.writeFieldStop()
16138 
    oprot.writeStructEnd()
16139 
 
16140 
  def validate(self):
16141 
    return
16142 
 
16143 
 
16144 
  def __repr__(self):
16145 
    L = ['%s=%r' % (key, value)
16146 
      for key, value in self.__dict__.iteritems()]
16147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16148 
 
16149 
  def __eq__(self, other):
16150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16151 
 
16152 
  def __ne__(self, other):
16153 
    return not (self == other)
16154 
 
16155 
class markOrderCancellationRequestDenied_result:
16156 
  """
16157 
  Attributes:
16158 
   - ex
16159 
  """
16160 
 
16161 
  thrift_spec = (
16162 
    None, # 0
16163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16164 
  )
16165 
 
16166 
  def __init__(self, ex=None,):
16167 
    self.ex = ex
16168 
 
16169 
  def read(self, iprot):
16170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16172 
      return
16173 
    iprot.readStructBegin()
16174 
    while True:
16175 
      (fname, ftype, fid) = iprot.readFieldBegin()
16176 
      if ftype == TType.STOP:
16177 
        break
16178 
      if fid == 1:
16179 
        if ftype == TType.STRUCT:
16180 
          self.ex = TransactionServiceException()
16181 
          self.ex.read(iprot)
16182 
        else:
16183 
          iprot.skip(ftype)
16184 
      else:
16185 
        iprot.skip(ftype)
16186 
      iprot.readFieldEnd()
16187 
    iprot.readStructEnd()
16188 
 
16189 
  def write(self, oprot):
16190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16192 
      return
16193 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16194 
    if self.ex is not None:
16195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16196 
      self.ex.write(oprot)
16197 
      oprot.writeFieldEnd()
16198 
    oprot.writeFieldStop()
16199 
    oprot.writeStructEnd()
16200 
 
16201 
  def validate(self):
16202 
    return
16203 
 
16204 
 
16205 
  def __repr__(self):
16206 
    L = ['%s=%r' % (key, value)
16207 
      for key, value in self.__dict__.iteritems()]
16208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16209 
 
16210 
  def __eq__(self, other):
16211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16212 
 
16213 
  def __ne__(self, other):
16214 
    return not (self == other)
16215 
 
4258 rajveer 16216 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16217 
  """
16218 
  Attributes:
4258 rajveer 16219 
   - transactionId
4247 rajveer 16220 
  """
16221 
 
16222 
  thrift_spec = (
16223 
    None, # 0
4258 rajveer 16224 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16225 
  )
16226 
 
4258 rajveer 16227 
  def __init__(self, transactionId=None,):
16228 
    self.transactionId = transactionId
4247 rajveer 16229 
 
16230 
  def read(self, iprot):
16231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16233 
      return
16234 
    iprot.readStructBegin()
16235 
    while True:
16236 
      (fname, ftype, fid) = iprot.readFieldBegin()
16237 
      if ftype == TType.STOP:
16238 
        break
16239 
      if fid == 1:
16240 
        if ftype == TType.I64:
4258 rajveer 16241 
          self.transactionId = iprot.readI64();
4247 rajveer 16242 
        else:
16243 
          iprot.skip(ftype)
16244 
      else:
16245 
        iprot.skip(ftype)
16246 
      iprot.readFieldEnd()
16247 
    iprot.readStructEnd()
16248 
 
16249 
  def write(self, oprot):
16250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16252 
      return
4258 rajveer 16253 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16254 
    if self.transactionId is not None:
16255 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16256 
      oprot.writeI64(self.transactionId)
4247 rajveer 16257 
      oprot.writeFieldEnd()
16258 
    oprot.writeFieldStop()
16259 
    oprot.writeStructEnd()
16260 
 
16261 
  def validate(self):
16262 
    return
16263 
 
16264 
 
16265 
  def __repr__(self):
16266 
    L = ['%s=%r' % (key, value)
16267 
      for key, value in self.__dict__.iteritems()]
16268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16269 
 
16270 
  def __eq__(self, other):
16271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16272 
 
16273 
  def __ne__(self, other):
16274 
    return not (self == other)
16275 
 
4258 rajveer 16276 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16277 
  """
16278 
  Attributes:
16279 
   - ex
16280 
  """
16281 
 
16282 
  thrift_spec = (
16283 
    None, # 0
16284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16285 
  )
16286 
 
16287 
  def __init__(self, ex=None,):
16288 
    self.ex = ex
16289 
 
16290 
  def read(self, iprot):
16291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16293 
      return
16294 
    iprot.readStructBegin()
16295 
    while True:
16296 
      (fname, ftype, fid) = iprot.readFieldBegin()
16297 
      if ftype == TType.STOP:
16298 
        break
16299 
      if fid == 1:
16300 
        if ftype == TType.STRUCT:
16301 
          self.ex = TransactionServiceException()
16302 
          self.ex.read(iprot)
16303 
        else:
16304 
          iprot.skip(ftype)
16305 
      else:
16306 
        iprot.skip(ftype)
16307 
      iprot.readFieldEnd()
16308 
    iprot.readStructEnd()
16309 
 
16310 
  def write(self, oprot):
16311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16313 
      return
4258 rajveer 16314 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16315 
    if self.ex is not None:
16316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16317 
      self.ex.write(oprot)
16318 
      oprot.writeFieldEnd()
16319 
    oprot.writeFieldStop()
16320 
    oprot.writeStructEnd()
16321 
 
16322 
  def validate(self):
16323 
    return
16324 
 
16325 
 
16326 
  def __repr__(self):
16327 
    L = ['%s=%r' % (key, value)
16328 
      for key, value in self.__dict__.iteritems()]
16329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16330 
 
16331 
  def __eq__(self, other):
16332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16333 
 
16334 
  def __ne__(self, other):
16335 
    return not (self == other)
4259 anupam.sin 16336 
 
16337 
class refundTransaction_args:
16338 
  """
16339 
  Attributes:
16340 
   - transactionId
16341 
   - refundedBy
16342 
   - reason
16343 
  """
16344 
 
16345 
  thrift_spec = (
16346 
    None, # 0
16347 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16348 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16349 
    (3, TType.STRING, 'reason', None, None, ), # 3
16350 
  )
16351 
 
16352 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16353 
    self.transactionId = transactionId
16354 
    self.refundedBy = refundedBy
16355 
    self.reason = reason
16356 
 
16357 
  def read(self, iprot):
16358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16360 
      return
16361 
    iprot.readStructBegin()
16362 
    while True:
16363 
      (fname, ftype, fid) = iprot.readFieldBegin()
16364 
      if ftype == TType.STOP:
16365 
        break
16366 
      if fid == 1:
16367 
        if ftype == TType.I64:
16368 
          self.transactionId = iprot.readI64();
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      elif fid == 2:
16372 
        if ftype == TType.STRING:
16373 
          self.refundedBy = iprot.readString();
16374 
        else:
16375 
          iprot.skip(ftype)
16376 
      elif fid == 3:
16377 
        if ftype == TType.STRING:
16378 
          self.reason = iprot.readString();
16379 
        else:
16380 
          iprot.skip(ftype)
16381 
      else:
16382 
        iprot.skip(ftype)
16383 
      iprot.readFieldEnd()
16384 
    iprot.readStructEnd()
16385 
 
16386 
  def write(self, oprot):
16387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16389 
      return
16390 
    oprot.writeStructBegin('refundTransaction_args')
16391 
    if self.transactionId is not None:
16392 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16393 
      oprot.writeI64(self.transactionId)
16394 
      oprot.writeFieldEnd()
16395 
    if self.refundedBy is not None:
16396 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16397 
      oprot.writeString(self.refundedBy)
16398 
      oprot.writeFieldEnd()
16399 
    if self.reason is not None:
16400 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16401 
      oprot.writeString(self.reason)
16402 
      oprot.writeFieldEnd()
16403 
    oprot.writeFieldStop()
16404 
    oprot.writeStructEnd()
16405 
 
16406 
  def validate(self):
16407 
    return
16408 
 
16409 
 
16410 
  def __repr__(self):
16411 
    L = ['%s=%r' % (key, value)
16412 
      for key, value in self.__dict__.iteritems()]
16413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16414 
 
16415 
  def __eq__(self, other):
16416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16417 
 
16418 
  def __ne__(self, other):
16419 
    return not (self == other)
16420 
 
16421 
class refundTransaction_result:
16422 
  """
16423 
  Attributes:
16424 
   - ex
16425 
  """
16426 
 
16427 
  thrift_spec = (
16428 
    None, # 0
16429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16430 
  )
16431 
 
16432 
  def __init__(self, ex=None,):
16433 
    self.ex = ex
16434 
 
16435 
  def read(self, iprot):
16436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16438 
      return
16439 
    iprot.readStructBegin()
16440 
    while True:
16441 
      (fname, ftype, fid) = iprot.readFieldBegin()
16442 
      if ftype == TType.STOP:
16443 
        break
16444 
      if fid == 1:
16445 
        if ftype == TType.STRUCT:
16446 
          self.ex = TransactionServiceException()
16447 
          self.ex.read(iprot)
16448 
        else:
16449 
          iprot.skip(ftype)
16450 
      else:
16451 
        iprot.skip(ftype)
16452 
      iprot.readFieldEnd()
16453 
    iprot.readStructEnd()
16454 
 
16455 
  def write(self, oprot):
16456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16458 
      return
16459 
    oprot.writeStructBegin('refundTransaction_result')
16460 
    if self.ex is not None:
16461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16462 
      self.ex.write(oprot)
16463 
      oprot.writeFieldEnd()
16464 
    oprot.writeFieldStop()
16465 
    oprot.writeStructEnd()
16466 
 
16467 
  def validate(self):
16468 
    return
16469 
 
16470 
 
16471 
  def __repr__(self):
16472 
    L = ['%s=%r' % (key, value)
16473 
      for key, value in self.__dict__.iteritems()]
16474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16475 
 
16476 
  def __eq__(self, other):
16477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16478 
 
16479 
  def __ne__(self, other):
16480 
    return not (self == other)
4285 rajveer 16481 
 
4324 mandeep.dh 16482 
class updateShipmentAddress_args:
16483 
  """
16484 
  Attributes:
16485 
   - orderId
16486 
   - addressId
16487 
  """
16488 
 
16489 
  thrift_spec = (
16490 
    None, # 0
16491 
    (1, TType.I64, 'orderId', None, None, ), # 1
16492 
    (2, TType.I64, 'addressId', None, None, ), # 2
16493 
  )
16494 
 
16495 
  def __init__(self, orderId=None, addressId=None,):
16496 
    self.orderId = orderId
16497 
    self.addressId = addressId
16498 
 
16499 
  def read(self, iprot):
16500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16502 
      return
16503 
    iprot.readStructBegin()
16504 
    while True:
16505 
      (fname, ftype, fid) = iprot.readFieldBegin()
16506 
      if ftype == TType.STOP:
16507 
        break
16508 
      if fid == 1:
16509 
        if ftype == TType.I64:
16510 
          self.orderId = iprot.readI64();
16511 
        else:
16512 
          iprot.skip(ftype)
16513 
      elif fid == 2:
16514 
        if ftype == TType.I64:
16515 
          self.addressId = iprot.readI64();
16516 
        else:
16517 
          iprot.skip(ftype)
16518 
      else:
16519 
        iprot.skip(ftype)
16520 
      iprot.readFieldEnd()
16521 
    iprot.readStructEnd()
16522 
 
16523 
  def write(self, oprot):
16524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16526 
      return
16527 
    oprot.writeStructBegin('updateShipmentAddress_args')
16528 
    if self.orderId is not None:
16529 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16530 
      oprot.writeI64(self.orderId)
16531 
      oprot.writeFieldEnd()
16532 
    if self.addressId is not None:
16533 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16534 
      oprot.writeI64(self.addressId)
16535 
      oprot.writeFieldEnd()
16536 
    oprot.writeFieldStop()
16537 
    oprot.writeStructEnd()
16538 
 
16539 
  def validate(self):
16540 
    return
16541 
 
16542 
 
16543 
  def __repr__(self):
16544 
    L = ['%s=%r' % (key, value)
16545 
      for key, value in self.__dict__.iteritems()]
16546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16547 
 
16548 
  def __eq__(self, other):
16549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16550 
 
16551 
  def __ne__(self, other):
16552 
    return not (self == other)
16553 
 
16554 
class updateShipmentAddress_result:
16555 
  """
16556 
  Attributes:
16557 
   - ex
16558 
  """
16559 
 
16560 
  thrift_spec = (
16561 
    None, # 0
16562 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16563 
  )
16564 
 
16565 
  def __init__(self, ex=None,):
16566 
    self.ex = ex
16567 
 
16568 
  def read(self, iprot):
16569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16571 
      return
16572 
    iprot.readStructBegin()
16573 
    while True:
16574 
      (fname, ftype, fid) = iprot.readFieldBegin()
16575 
      if ftype == TType.STOP:
16576 
        break
16577 
      if fid == 1:
16578 
        if ftype == TType.STRUCT:
16579 
          self.ex = TransactionServiceException()
16580 
          self.ex.read(iprot)
16581 
        else:
16582 
          iprot.skip(ftype)
16583 
      else:
16584 
        iprot.skip(ftype)
16585 
      iprot.readFieldEnd()
16586 
    iprot.readStructEnd()
16587 
 
16588 
  def write(self, oprot):
16589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16591 
      return
16592 
    oprot.writeStructBegin('updateShipmentAddress_result')
16593 
    if self.ex is not None:
16594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16595 
      self.ex.write(oprot)
16596 
      oprot.writeFieldEnd()
16597 
    oprot.writeFieldStop()
16598 
    oprot.writeStructEnd()
16599 
 
16600 
  def validate(self):
16601 
    return
16602 
 
16603 
 
16604 
  def __repr__(self):
16605 
    L = ['%s=%r' % (key, value)
16606 
      for key, value in self.__dict__.iteritems()]
16607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16608 
 
16609 
  def __eq__(self, other):
16610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16611 
 
16612 
  def __ne__(self, other):
16613 
    return not (self == other)
16614 
 
4285 rajveer 16615 
class acceptOrdersForItemId_args:
16616 
  """
16617 
  Attributes:
16618 
   - itemId
16619 
   - inventory
16620 
  """
16621 
 
16622 
  thrift_spec = (
16623 
    None, # 0
16624 
    (1, TType.I64, 'itemId', None, None, ), # 1
16625 
    (2, TType.I64, 'inventory', None, None, ), # 2
16626 
  )
16627 
 
16628 
  def __init__(self, itemId=None, inventory=None,):
16629 
    self.itemId = itemId
16630 
    self.inventory = inventory
16631 
 
16632 
  def read(self, iprot):
16633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16635 
      return
16636 
    iprot.readStructBegin()
16637 
    while True:
16638 
      (fname, ftype, fid) = iprot.readFieldBegin()
16639 
      if ftype == TType.STOP:
16640 
        break
16641 
      if fid == 1:
16642 
        if ftype == TType.I64:
16643 
          self.itemId = iprot.readI64();
16644 
        else:
16645 
          iprot.skip(ftype)
16646 
      elif fid == 2:
16647 
        if ftype == TType.I64:
16648 
          self.inventory = iprot.readI64();
16649 
        else:
16650 
          iprot.skip(ftype)
16651 
      else:
16652 
        iprot.skip(ftype)
16653 
      iprot.readFieldEnd()
16654 
    iprot.readStructEnd()
16655 
 
16656 
  def write(self, oprot):
16657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16659 
      return
16660 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16661 
    if self.itemId is not None:
16662 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16663 
      oprot.writeI64(self.itemId)
16664 
      oprot.writeFieldEnd()
16665 
    if self.inventory is not None:
16666 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16667 
      oprot.writeI64(self.inventory)
16668 
      oprot.writeFieldEnd()
16669 
    oprot.writeFieldStop()
16670 
    oprot.writeStructEnd()
16671 
 
16672 
  def validate(self):
16673 
    return
16674 
 
16675 
 
16676 
  def __repr__(self):
16677 
    L = ['%s=%r' % (key, value)
16678 
      for key, value in self.__dict__.iteritems()]
16679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16680 
 
16681 
  def __eq__(self, other):
16682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16683 
 
16684 
  def __ne__(self, other):
16685 
    return not (self == other)
16686 
 
16687 
class acceptOrdersForItemId_result:
16688 
  """
16689 
  Attributes:
16690 
   - success
16691 
   - ex
16692 
  """
16693 
 
16694 
  thrift_spec = (
16695 
    (0, TType.BOOL, 'success', None, None, ), # 0
16696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16697 
  )
16698 
 
16699 
  def __init__(self, success=None, ex=None,):
16700 
    self.success = success
16701 
    self.ex = ex
16702 
 
16703 
  def read(self, iprot):
16704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16706 
      return
16707 
    iprot.readStructBegin()
16708 
    while True:
16709 
      (fname, ftype, fid) = iprot.readFieldBegin()
16710 
      if ftype == TType.STOP:
16711 
        break
16712 
      if fid == 0:
16713 
        if ftype == TType.BOOL:
16714 
          self.success = iprot.readBool();
16715 
        else:
16716 
          iprot.skip(ftype)
16717 
      elif fid == 1:
16718 
        if ftype == TType.STRUCT:
16719 
          self.ex = TransactionServiceException()
16720 
          self.ex.read(iprot)
16721 
        else:
16722 
          iprot.skip(ftype)
16723 
      else:
16724 
        iprot.skip(ftype)
16725 
      iprot.readFieldEnd()
16726 
    iprot.readStructEnd()
16727 
 
16728 
  def write(self, oprot):
16729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16731 
      return
16732 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16733 
    if self.success is not None:
16734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16735 
      oprot.writeBool(self.success)
16736 
      oprot.writeFieldEnd()
16737 
    if self.ex is not None:
16738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16739 
      self.ex.write(oprot)
16740 
      oprot.writeFieldEnd()
16741 
    oprot.writeFieldStop()
16742 
    oprot.writeStructEnd()
16743 
 
16744 
  def validate(self):
16745 
    return
16746 
 
16747 
 
16748 
  def __repr__(self):
16749 
    L = ['%s=%r' % (key, value)
16750 
      for key, value in self.__dict__.iteritems()]
16751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16752 
 
16753 
  def __eq__(self, other):
16754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16755 
 
16756 
  def __ne__(self, other):
16757 
    return not (self == other)
4303 rajveer 16758 
 
16759 
class markOrdersAsPORaised_args:
16760 
  """
16761 
  Attributes:
16762 
   - vendorId
16763 
   - itemId
16764 
   - quantity
16765 
   - estimate
4369 rajveer 16766 
   - isReminder
4303 rajveer 16767 
  """
16768 
 
16769 
  thrift_spec = (
16770 
    None, # 0
16771 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16772 
    (2, TType.I64, 'itemId', None, None, ), # 2
16773 
    (3, TType.I64, 'quantity', None, None, ), # 3
16774 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16775 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16776 
  )
16777 
 
4369 rajveer 16778 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16779 
    self.vendorId = vendorId
16780 
    self.itemId = itemId
16781 
    self.quantity = quantity
16782 
    self.estimate = estimate
4369 rajveer 16783 
    self.isReminder = isReminder
4303 rajveer 16784 
 
16785 
  def read(self, iprot):
16786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16788 
      return
16789 
    iprot.readStructBegin()
16790 
    while True:
16791 
      (fname, ftype, fid) = iprot.readFieldBegin()
16792 
      if ftype == TType.STOP:
16793 
        break
16794 
      if fid == 1:
16795 
        if ftype == TType.I64:
16796 
          self.vendorId = iprot.readI64();
16797 
        else:
16798 
          iprot.skip(ftype)
16799 
      elif fid == 2:
16800 
        if ftype == TType.I64:
16801 
          self.itemId = iprot.readI64();
16802 
        else:
16803 
          iprot.skip(ftype)
16804 
      elif fid == 3:
16805 
        if ftype == TType.I64:
16806 
          self.quantity = iprot.readI64();
16807 
        else:
16808 
          iprot.skip(ftype)
16809 
      elif fid == 4:
16810 
        if ftype == TType.I64:
16811 
          self.estimate = iprot.readI64();
16812 
        else:
16813 
          iprot.skip(ftype)
4369 rajveer 16814 
      elif fid == 5:
16815 
        if ftype == TType.BOOL:
16816 
          self.isReminder = iprot.readBool();
16817 
        else:
16818 
          iprot.skip(ftype)
4303 rajveer 16819 
      else:
16820 
        iprot.skip(ftype)
16821 
      iprot.readFieldEnd()
16822 
    iprot.readStructEnd()
16823 
 
16824 
  def write(self, oprot):
16825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16827 
      return
16828 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16829 
    if self.vendorId is not None:
16830 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16831 
      oprot.writeI64(self.vendorId)
16832 
      oprot.writeFieldEnd()
16833 
    if self.itemId is not None:
16834 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16835 
      oprot.writeI64(self.itemId)
16836 
      oprot.writeFieldEnd()
16837 
    if self.quantity is not None:
16838 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16839 
      oprot.writeI64(self.quantity)
16840 
      oprot.writeFieldEnd()
16841 
    if self.estimate is not None:
16842 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16843 
      oprot.writeI64(self.estimate)
16844 
      oprot.writeFieldEnd()
4369 rajveer 16845 
    if self.isReminder is not None:
16846 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16847 
      oprot.writeBool(self.isReminder)
16848 
      oprot.writeFieldEnd()
4303 rajveer 16849 
    oprot.writeFieldStop()
16850 
    oprot.writeStructEnd()
16851 
 
16852 
  def validate(self):
16853 
    return
16854 
 
16855 
 
16856 
  def __repr__(self):
16857 
    L = ['%s=%r' % (key, value)
16858 
      for key, value in self.__dict__.iteritems()]
16859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16860 
 
16861 
  def __eq__(self, other):
16862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16863 
 
16864 
  def __ne__(self, other):
16865 
    return not (self == other)
16866 
 
16867 
class markOrdersAsPORaised_result:
16868 
  """
16869 
  Attributes:
16870 
   - ex
16871 
  """
16872 
 
16873 
  thrift_spec = (
16874 
    None, # 0
16875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16876 
  )
16877 
 
16878 
  def __init__(self, ex=None,):
16879 
    self.ex = ex
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.STRUCT:
16892 
          self.ex = TransactionServiceException()
16893 
          self.ex.read(iprot)
16894 
        else:
16895 
          iprot.skip(ftype)
16896 
      else:
16897 
        iprot.skip(ftype)
16898 
      iprot.readFieldEnd()
16899 
    iprot.readStructEnd()
16900 
 
16901 
  def write(self, oprot):
16902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16904 
      return
16905 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16906 
    if self.ex is not None:
16907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16908 
      self.ex.write(oprot)
16909 
      oprot.writeFieldEnd()
16910 
    oprot.writeFieldStop()
16911 
    oprot.writeStructEnd()
16912 
 
16913 
  def validate(self):
16914 
    return
16915 
 
16916 
 
16917 
  def __repr__(self):
16918 
    L = ['%s=%r' % (key, value)
16919 
      for key, value in self.__dict__.iteritems()]
16920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16921 
 
16922 
  def __eq__(self, other):
16923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16924 
 
16925 
  def __ne__(self, other):
16926 
    return not (self == other)
16927 
 
16928 
class markOrdersAsReversalInitiated_args:
16929 
  """
16930 
  Attributes:
16931 
   - vendorId
16932 
   - itemId
16933 
   - quantity
16934 
   - estimate
4369 rajveer 16935 
   - isReminder
4303 rajveer 16936 
  """
16937 
 
16938 
  thrift_spec = (
16939 
    None, # 0
16940 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16941 
    (2, TType.I64, 'itemId', None, None, ), # 2
16942 
    (3, TType.I64, 'quantity', None, None, ), # 3
16943 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16944 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16945 
  )
16946 
 
4369 rajveer 16947 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16948 
    self.vendorId = vendorId
16949 
    self.itemId = itemId
16950 
    self.quantity = quantity
16951 
    self.estimate = estimate
4369 rajveer 16952 
    self.isReminder = isReminder
4303 rajveer 16953 
 
16954 
  def read(self, iprot):
16955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16957 
      return
16958 
    iprot.readStructBegin()
16959 
    while True:
16960 
      (fname, ftype, fid) = iprot.readFieldBegin()
16961 
      if ftype == TType.STOP:
16962 
        break
16963 
      if fid == 1:
16964 
        if ftype == TType.I64:
16965 
          self.vendorId = iprot.readI64();
16966 
        else:
16967 
          iprot.skip(ftype)
16968 
      elif fid == 2:
16969 
        if ftype == TType.I64:
16970 
          self.itemId = iprot.readI64();
16971 
        else:
16972 
          iprot.skip(ftype)
16973 
      elif fid == 3:
16974 
        if ftype == TType.I64:
16975 
          self.quantity = iprot.readI64();
16976 
        else:
16977 
          iprot.skip(ftype)
16978 
      elif fid == 4:
16979 
        if ftype == TType.I64:
16980 
          self.estimate = iprot.readI64();
16981 
        else:
16982 
          iprot.skip(ftype)
4369 rajveer 16983 
      elif fid == 5:
16984 
        if ftype == TType.BOOL:
16985 
          self.isReminder = iprot.readBool();
16986 
        else:
16987 
          iprot.skip(ftype)
4303 rajveer 16988 
      else:
16989 
        iprot.skip(ftype)
16990 
      iprot.readFieldEnd()
16991 
    iprot.readStructEnd()
16992 
 
16993 
  def write(self, oprot):
16994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16996 
      return
16997 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16998 
    if self.vendorId is not None:
16999 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17000 
      oprot.writeI64(self.vendorId)
17001 
      oprot.writeFieldEnd()
17002 
    if self.itemId is not None:
17003 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17004 
      oprot.writeI64(self.itemId)
17005 
      oprot.writeFieldEnd()
17006 
    if self.quantity is not None:
17007 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17008 
      oprot.writeI64(self.quantity)
17009 
      oprot.writeFieldEnd()
17010 
    if self.estimate is not None:
17011 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17012 
      oprot.writeI64(self.estimate)
17013 
      oprot.writeFieldEnd()
4369 rajveer 17014 
    if self.isReminder is not None:
17015 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17016 
      oprot.writeBool(self.isReminder)
17017 
      oprot.writeFieldEnd()
4303 rajveer 17018 
    oprot.writeFieldStop()
17019 
    oprot.writeStructEnd()
17020 
 
17021 
  def validate(self):
17022 
    return
17023 
 
17024 
 
17025 
  def __repr__(self):
17026 
    L = ['%s=%r' % (key, value)
17027 
      for key, value in self.__dict__.iteritems()]
17028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17029 
 
17030 
  def __eq__(self, other):
17031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17032 
 
17033 
  def __ne__(self, other):
17034 
    return not (self == other)
17035 
 
17036 
class markOrdersAsReversalInitiated_result:
17037 
  """
17038 
  Attributes:
17039 
   - ex
17040 
  """
17041 
 
17042 
  thrift_spec = (
17043 
    None, # 0
17044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17045 
  )
17046 
 
17047 
  def __init__(self, ex=None,):
17048 
    self.ex = ex
17049 
 
17050 
  def read(self, iprot):
17051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17053 
      return
17054 
    iprot.readStructBegin()
17055 
    while True:
17056 
      (fname, ftype, fid) = iprot.readFieldBegin()
17057 
      if ftype == TType.STOP:
17058 
        break
17059 
      if fid == 1:
17060 
        if ftype == TType.STRUCT:
17061 
          self.ex = TransactionServiceException()
17062 
          self.ex.read(iprot)
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17075 
    if self.ex is not None:
17076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17077 
      self.ex.write(oprot)
17078 
      oprot.writeFieldEnd()
17079 
    oprot.writeFieldStop()
17080 
    oprot.writeStructEnd()
17081 
 
17082 
  def validate(self):
17083 
    return
17084 
 
17085 
 
17086 
  def __repr__(self):
17087 
    L = ['%s=%r' % (key, value)
17088 
      for key, value in self.__dict__.iteritems()]
17089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17090 
 
17091 
  def __eq__(self, other):
17092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17093 
 
17094 
  def __ne__(self, other):
17095 
    return not (self == other)
17096 
 
17097 
class markOrdersAsNotAvailabke_args:
17098 
  """
17099 
  Attributes:
17100 
   - vendorId
17101 
   - itemId
17102 
   - quantity
17103 
   - estimate
4369 rajveer 17104 
   - isReminder
4303 rajveer 17105 
  """
17106 
 
17107 
  thrift_spec = (
17108 
    None, # 0
17109 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17110 
    (2, TType.I64, 'itemId', None, None, ), # 2
17111 
    (3, TType.I64, 'quantity', None, None, ), # 3
17112 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17113 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17114 
  )
17115 
 
4369 rajveer 17116 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17117 
    self.vendorId = vendorId
17118 
    self.itemId = itemId
17119 
    self.quantity = quantity
17120 
    self.estimate = estimate
4369 rajveer 17121 
    self.isReminder = isReminder
4303 rajveer 17122 
 
17123 
  def read(self, iprot):
17124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17126 
      return
17127 
    iprot.readStructBegin()
17128 
    while True:
17129 
      (fname, ftype, fid) = iprot.readFieldBegin()
17130 
      if ftype == TType.STOP:
17131 
        break
17132 
      if fid == 1:
17133 
        if ftype == TType.I64:
17134 
          self.vendorId = iprot.readI64();
17135 
        else:
17136 
          iprot.skip(ftype)
17137 
      elif fid == 2:
17138 
        if ftype == TType.I64:
17139 
          self.itemId = iprot.readI64();
17140 
        else:
17141 
          iprot.skip(ftype)
17142 
      elif fid == 3:
17143 
        if ftype == TType.I64:
17144 
          self.quantity = iprot.readI64();
17145 
        else:
17146 
          iprot.skip(ftype)
17147 
      elif fid == 4:
17148 
        if ftype == TType.I64:
17149 
          self.estimate = iprot.readI64();
17150 
        else:
17151 
          iprot.skip(ftype)
4369 rajveer 17152 
      elif fid == 5:
17153 
        if ftype == TType.BOOL:
17154 
          self.isReminder = iprot.readBool();
17155 
        else:
17156 
          iprot.skip(ftype)
4303 rajveer 17157 
      else:
17158 
        iprot.skip(ftype)
17159 
      iprot.readFieldEnd()
17160 
    iprot.readStructEnd()
17161 
 
17162 
  def write(self, oprot):
17163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17165 
      return
17166 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17167 
    if self.vendorId is not None:
17168 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17169 
      oprot.writeI64(self.vendorId)
17170 
      oprot.writeFieldEnd()
17171 
    if self.itemId is not None:
17172 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17173 
      oprot.writeI64(self.itemId)
17174 
      oprot.writeFieldEnd()
17175 
    if self.quantity is not None:
17176 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17177 
      oprot.writeI64(self.quantity)
17178 
      oprot.writeFieldEnd()
17179 
    if self.estimate is not None:
17180 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17181 
      oprot.writeI64(self.estimate)
17182 
      oprot.writeFieldEnd()
4369 rajveer 17183 
    if self.isReminder is not None:
17184 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17185 
      oprot.writeBool(self.isReminder)
17186 
      oprot.writeFieldEnd()
4303 rajveer 17187 
    oprot.writeFieldStop()
17188 
    oprot.writeStructEnd()
17189 
 
17190 
  def validate(self):
17191 
    return
17192 
 
17193 
 
17194 
  def __repr__(self):
17195 
    L = ['%s=%r' % (key, value)
17196 
      for key, value in self.__dict__.iteritems()]
17197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17198 
 
17199 
  def __eq__(self, other):
17200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17201 
 
17202 
  def __ne__(self, other):
17203 
    return not (self == other)
17204 
 
17205 
class markOrdersAsNotAvailabke_result:
17206 
  """
17207 
  Attributes:
17208 
   - ex
17209 
  """
17210 
 
17211 
  thrift_spec = (
17212 
    None, # 0
17213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17214 
  )
17215 
 
17216 
  def __init__(self, ex=None,):
17217 
    self.ex = ex
17218 
 
17219 
  def read(self, iprot):
17220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17222 
      return
17223 
    iprot.readStructBegin()
17224 
    while True:
17225 
      (fname, ftype, fid) = iprot.readFieldBegin()
17226 
      if ftype == TType.STOP:
17227 
        break
17228 
      if fid == 1:
17229 
        if ftype == TType.STRUCT:
17230 
          self.ex = TransactionServiceException()
17231 
          self.ex.read(iprot)
17232 
        else:
17233 
          iprot.skip(ftype)
17234 
      else:
17235 
        iprot.skip(ftype)
17236 
      iprot.readFieldEnd()
17237 
    iprot.readStructEnd()
17238 
 
17239 
  def write(self, oprot):
17240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17242 
      return
17243 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17244 
    if self.ex is not None:
17245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17246 
      self.ex.write(oprot)
17247 
      oprot.writeFieldEnd()
17248 
    oprot.writeFieldStop()
17249 
    oprot.writeStructEnd()
17250 
 
17251 
  def validate(self):
17252 
    return
17253 
 
17254 
 
17255 
  def __repr__(self):
17256 
    L = ['%s=%r' % (key, value)
17257 
      for key, value in self.__dict__.iteritems()]
17258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17259 
 
17260 
  def __eq__(self, other):
17261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17262 
 
17263 
  def __ne__(self, other):
17264 
    return not (self == other)
4369 rajveer 17265 
 
17266 
class markOrdersAsTimeout_args:
17267 
  """
17268 
  Attributes:
17269 
   - vendorId
17270 
  """
17271 
 
17272 
  thrift_spec = (
17273 
    None, # 0
17274 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17275 
  )
17276 
 
17277 
  def __init__(self, vendorId=None,):
17278 
    self.vendorId = vendorId
17279 
 
17280 
  def read(self, iprot):
17281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17283 
      return
17284 
    iprot.readStructBegin()
17285 
    while True:
17286 
      (fname, ftype, fid) = iprot.readFieldBegin()
17287 
      if ftype == TType.STOP:
17288 
        break
17289 
      if fid == 1:
17290 
        if ftype == TType.I64:
17291 
          self.vendorId = iprot.readI64();
17292 
        else:
17293 
          iprot.skip(ftype)
17294 
      else:
17295 
        iprot.skip(ftype)
17296 
      iprot.readFieldEnd()
17297 
    iprot.readStructEnd()
17298 
 
17299 
  def write(self, oprot):
17300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17302 
      return
17303 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17304 
    if self.vendorId is not None:
17305 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17306 
      oprot.writeI64(self.vendorId)
17307 
      oprot.writeFieldEnd()
17308 
    oprot.writeFieldStop()
17309 
    oprot.writeStructEnd()
17310 
 
17311 
  def validate(self):
17312 
    return
17313 
 
17314 
 
17315 
  def __repr__(self):
17316 
    L = ['%s=%r' % (key, value)
17317 
      for key, value in self.__dict__.iteritems()]
17318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17319 
 
17320 
  def __eq__(self, other):
17321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17322 
 
17323 
  def __ne__(self, other):
17324 
    return not (self == other)
17325 
 
17326 
class markOrdersAsTimeout_result:
17327 
  """
17328 
  Attributes:
17329 
   - success
17330 
   - ex
17331 
  """
17332 
 
17333 
  thrift_spec = (
17334 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17336 
  )
17337 
 
17338 
  def __init__(self, success=None, ex=None,):
17339 
    self.success = success
17340 
    self.ex = ex
17341 
 
17342 
  def read(self, iprot):
17343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17345 
      return
17346 
    iprot.readStructBegin()
17347 
    while True:
17348 
      (fname, ftype, fid) = iprot.readFieldBegin()
17349 
      if ftype == TType.STOP:
17350 
        break
17351 
      if fid == 0:
17352 
        if ftype == TType.MAP:
17353 
          self.success = {}
4783 phani.kuma 17354 
          (_ktype292, _vtype293, _size291 ) = iprot.readMapBegin()
17355 
          for _i295 in xrange(_size291):
17356 
            _key296 = iprot.readI32();
17357 
            _val297 = TimeoutSummary()
17358 
            _val297.read(iprot)
17359 
            self.success[_key296] = _val297
4369 rajveer 17360 
          iprot.readMapEnd()
17361 
        else:
17362 
          iprot.skip(ftype)
17363 
      elif fid == 1:
17364 
        if ftype == TType.STRUCT:
17365 
          self.ex = TransactionServiceException()
17366 
          self.ex.read(iprot)
17367 
        else:
17368 
          iprot.skip(ftype)
17369 
      else:
17370 
        iprot.skip(ftype)
17371 
      iprot.readFieldEnd()
17372 
    iprot.readStructEnd()
17373 
 
17374 
  def write(self, oprot):
17375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17377 
      return
17378 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17379 
    if self.success is not None:
17380 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17381 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4783 phani.kuma 17382 
      for kiter298,viter299 in self.success.items():
17383 
        oprot.writeI32(kiter298)
17384 
        viter299.write(oprot)
4369 rajveer 17385 
      oprot.writeMapEnd()
17386 
      oprot.writeFieldEnd()
17387 
    if self.ex is not None:
17388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17389 
      self.ex.write(oprot)
17390 
      oprot.writeFieldEnd()
17391 
    oprot.writeFieldStop()
17392 
    oprot.writeStructEnd()
17393 
 
17394 
  def validate(self):
17395 
    return
17396 
 
17397 
 
17398 
  def __repr__(self):
17399 
    L = ['%s=%r' % (key, value)
17400 
      for key, value in self.__dict__.iteritems()]
17401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17402 
 
17403 
  def __eq__(self, other):
17404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17405 
 
17406 
  def __ne__(self, other):
17407 
    return not (self == other)
4386 anupam.sin 17408 
 
4662 rajveer 17409 
class markOrderAsLostInTransit_args:
17410 
  """
17411 
  Attributes:
17412 
   - orderId
17413 
  """
17414 
 
17415 
  thrift_spec = (
17416 
    None, # 0
17417 
    (1, TType.I64, 'orderId', None, None, ), # 1
17418 
  )
17419 
 
17420 
  def __init__(self, orderId=None,):
17421 
    self.orderId = orderId
17422 
 
17423 
  def read(self, iprot):
17424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17426 
      return
17427 
    iprot.readStructBegin()
17428 
    while True:
17429 
      (fname, ftype, fid) = iprot.readFieldBegin()
17430 
      if ftype == TType.STOP:
17431 
        break
17432 
      if fid == 1:
17433 
        if ftype == TType.I64:
17434 
          self.orderId = iprot.readI64();
17435 
        else:
17436 
          iprot.skip(ftype)
17437 
      else:
17438 
        iprot.skip(ftype)
17439 
      iprot.readFieldEnd()
17440 
    iprot.readStructEnd()
17441 
 
17442 
  def write(self, oprot):
17443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17445 
      return
17446 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17447 
    if self.orderId is not None:
17448 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17449 
      oprot.writeI64(self.orderId)
17450 
      oprot.writeFieldEnd()
17451 
    oprot.writeFieldStop()
17452 
    oprot.writeStructEnd()
17453 
 
17454 
  def validate(self):
17455 
    return
17456 
 
17457 
 
17458 
  def __repr__(self):
17459 
    L = ['%s=%r' % (key, value)
17460 
      for key, value in self.__dict__.iteritems()]
17461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17462 
 
17463 
  def __eq__(self, other):
17464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17465 
 
17466 
  def __ne__(self, other):
17467 
    return not (self == other)
17468 
 
17469 
class markOrderAsLostInTransit_result:
17470 
  """
17471 
  Attributes:
17472 
   - success
17473 
   - ex
17474 
  """
17475 
 
17476 
  thrift_spec = (
17477 
    (0, TType.BOOL, 'success', None, None, ), # 0
17478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17479 
  )
17480 
 
17481 
  def __init__(self, success=None, ex=None,):
17482 
    self.success = success
17483 
    self.ex = ex
17484 
 
17485 
  def read(self, iprot):
17486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17488 
      return
17489 
    iprot.readStructBegin()
17490 
    while True:
17491 
      (fname, ftype, fid) = iprot.readFieldBegin()
17492 
      if ftype == TType.STOP:
17493 
        break
17494 
      if fid == 0:
17495 
        if ftype == TType.BOOL:
17496 
          self.success = iprot.readBool();
17497 
        else:
17498 
          iprot.skip(ftype)
17499 
      elif fid == 1:
17500 
        if ftype == TType.STRUCT:
17501 
          self.ex = TransactionServiceException()
17502 
          self.ex.read(iprot)
17503 
        else:
17504 
          iprot.skip(ftype)
17505 
      else:
17506 
        iprot.skip(ftype)
17507 
      iprot.readFieldEnd()
17508 
    iprot.readStructEnd()
17509 
 
17510 
  def write(self, oprot):
17511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17513 
      return
17514 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17515 
    if self.success is not None:
17516 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17517 
      oprot.writeBool(self.success)
17518 
      oprot.writeFieldEnd()
17519 
    if self.ex is not None:
17520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17521 
      self.ex.write(oprot)
17522 
      oprot.writeFieldEnd()
17523 
    oprot.writeFieldStop()
17524 
    oprot.writeStructEnd()
17525 
 
17526 
  def validate(self):
17527 
    return
17528 
 
17529 
 
17530 
  def __repr__(self):
17531 
    L = ['%s=%r' % (key, value)
17532 
      for key, value in self.__dict__.iteritems()]
17533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17534 
 
17535 
  def __eq__(self, other):
17536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17537 
 
17538 
  def __ne__(self, other):
17539 
    return not (self == other)
17540 
 
4386 anupam.sin 17541 
class getOrderForAwb_args:
17542 
  """
17543 
  Attributes:
17544 
   - awb
17545 
  """
17546 
 
17547 
  thrift_spec = (
17548 
    None, # 0
17549 
    (1, TType.STRING, 'awb', None, None, ), # 1
17550 
  )
17551 
 
17552 
  def __init__(self, awb=None,):
17553 
    self.awb = awb
17554 
 
17555 
  def read(self, iprot):
17556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17558 
      return
17559 
    iprot.readStructBegin()
17560 
    while True:
17561 
      (fname, ftype, fid) = iprot.readFieldBegin()
17562 
      if ftype == TType.STOP:
17563 
        break
17564 
      if fid == 1:
17565 
        if ftype == TType.STRING:
17566 
          self.awb = iprot.readString();
17567 
        else:
17568 
          iprot.skip(ftype)
17569 
      else:
17570 
        iprot.skip(ftype)
17571 
      iprot.readFieldEnd()
17572 
    iprot.readStructEnd()
17573 
 
17574 
  def write(self, oprot):
17575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17577 
      return
17578 
    oprot.writeStructBegin('getOrderForAwb_args')
17579 
    if self.awb is not None:
17580 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17581 
      oprot.writeString(self.awb)
17582 
      oprot.writeFieldEnd()
17583 
    oprot.writeFieldStop()
17584 
    oprot.writeStructEnd()
17585 
 
17586 
  def validate(self):
17587 
    return
17588 
 
17589 
 
17590 
  def __repr__(self):
17591 
    L = ['%s=%r' % (key, value)
17592 
      for key, value in self.__dict__.iteritems()]
17593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17594 
 
17595 
  def __eq__(self, other):
17596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17597 
 
17598 
  def __ne__(self, other):
17599 
    return not (self == other)
17600 
 
17601 
class getOrderForAwb_result:
17602 
  """
17603 
  Attributes:
17604 
   - success
17605 
   - ex
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17611 
  )
17612 
 
17613 
  def __init__(self, success=None, ex=None,):
17614 
    self.success = success
17615 
    self.ex = ex
17616 
 
17617 
  def read(self, iprot):
17618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17620 
      return
17621 
    iprot.readStructBegin()
17622 
    while True:
17623 
      (fname, ftype, fid) = iprot.readFieldBegin()
17624 
      if ftype == TType.STOP:
17625 
        break
17626 
      if fid == 0:
17627 
        if ftype == TType.STRUCT:
17628 
          self.success = Order()
17629 
          self.success.read(iprot)
17630 
        else:
17631 
          iprot.skip(ftype)
17632 
      elif fid == 1:
17633 
        if ftype == TType.STRUCT:
17634 
          self.ex = TransactionServiceException()
17635 
          self.ex.read(iprot)
17636 
        else:
17637 
          iprot.skip(ftype)
17638 
      else:
17639 
        iprot.skip(ftype)
17640 
      iprot.readFieldEnd()
17641 
    iprot.readStructEnd()
17642 
 
17643 
  def write(self, oprot):
17644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17646 
      return
17647 
    oprot.writeStructBegin('getOrderForAwb_result')
17648 
    if self.success is not None:
17649 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17650 
      self.success.write(oprot)
17651 
      oprot.writeFieldEnd()
17652 
    if self.ex is not None:
17653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17654 
      self.ex.write(oprot)
17655 
      oprot.writeFieldEnd()
17656 
    oprot.writeFieldStop()
17657 
    oprot.writeStructEnd()
17658 
 
17659 
  def validate(self):
17660 
    return
17661 
 
17662 
 
17663 
  def __repr__(self):
17664 
    L = ['%s=%r' % (key, value)
17665 
      for key, value in self.__dict__.iteritems()]
17666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17667 
 
17668 
  def __eq__(self, other):
17669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17670 
 
17671 
  def __ne__(self, other):
17672 
    return not (self == other)
4506 phani.kuma 17673 
 
17674 
class getOrdersForProviderForStatus_args:
17675 
  """
17676 
  Attributes:
17677 
   - logistics_provider_id
17678 
   - order_status
17679 
  """
17680 
 
17681 
  thrift_spec = (
17682 
    None, # 0
17683 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17684 
    (2, TType.I32, 'order_status', None, None, ), # 2
17685 
  )
17686 
 
17687 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17688 
    self.logistics_provider_id = logistics_provider_id
17689 
    self.order_status = order_status
17690 
 
17691 
  def read(self, iprot):
17692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17694 
      return
17695 
    iprot.readStructBegin()
17696 
    while True:
17697 
      (fname, ftype, fid) = iprot.readFieldBegin()
17698 
      if ftype == TType.STOP:
17699 
        break
17700 
      if fid == 1:
17701 
        if ftype == TType.I64:
17702 
          self.logistics_provider_id = iprot.readI64();
17703 
        else:
17704 
          iprot.skip(ftype)
17705 
      elif fid == 2:
17706 
        if ftype == TType.I32:
17707 
          self.order_status = iprot.readI32();
17708 
        else:
17709 
          iprot.skip(ftype)
17710 
      else:
17711 
        iprot.skip(ftype)
17712 
      iprot.readFieldEnd()
17713 
    iprot.readStructEnd()
17714 
 
17715 
  def write(self, oprot):
17716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17718 
      return
17719 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17720 
    if self.logistics_provider_id is not None:
17721 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17722 
      oprot.writeI64(self.logistics_provider_id)
17723 
      oprot.writeFieldEnd()
17724 
    if self.order_status is not None:
17725 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17726 
      oprot.writeI32(self.order_status)
17727 
      oprot.writeFieldEnd()
17728 
    oprot.writeFieldStop()
17729 
    oprot.writeStructEnd()
17730 
 
17731 
  def validate(self):
17732 
    return
17733 
 
17734 
 
17735 
  def __repr__(self):
17736 
    L = ['%s=%r' % (key, value)
17737 
      for key, value in self.__dict__.iteritems()]
17738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17739 
 
17740 
  def __eq__(self, other):
17741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17742 
 
17743 
  def __ne__(self, other):
17744 
    return not (self == other)
17745 
 
17746 
class getOrdersForProviderForStatus_result:
17747 
  """
17748 
  Attributes:
17749 
   - success
17750 
   - ex
17751 
  """
17752 
 
17753 
  thrift_spec = (
17754 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17756 
  )
17757 
 
17758 
  def __init__(self, success=None, ex=None,):
17759 
    self.success = success
17760 
    self.ex = ex
17761 
 
17762 
  def read(self, iprot):
17763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17765 
      return
17766 
    iprot.readStructBegin()
17767 
    while True:
17768 
      (fname, ftype, fid) = iprot.readFieldBegin()
17769 
      if ftype == TType.STOP:
17770 
        break
17771 
      if fid == 0:
17772 
        if ftype == TType.LIST:
17773 
          self.success = []
4783 phani.kuma 17774 
          (_etype303, _size300) = iprot.readListBegin()
17775 
          for _i304 in xrange(_size300):
17776 
            _elem305 = Order()
17777 
            _elem305.read(iprot)
17778 
            self.success.append(_elem305)
4506 phani.kuma 17779 
          iprot.readListEnd()
17780 
        else:
17781 
          iprot.skip(ftype)
17782 
      elif fid == 1:
17783 
        if ftype == TType.STRUCT:
17784 
          self.ex = TransactionServiceException()
17785 
          self.ex.read(iprot)
17786 
        else:
17787 
          iprot.skip(ftype)
17788 
      else:
17789 
        iprot.skip(ftype)
17790 
      iprot.readFieldEnd()
17791 
    iprot.readStructEnd()
17792 
 
17793 
  def write(self, oprot):
17794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17796 
      return
17797 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17798 
    if self.success is not None:
17799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 17801 
      for iter306 in self.success:
17802 
        iter306.write(oprot)
4506 phani.kuma 17803 
      oprot.writeListEnd()
17804 
      oprot.writeFieldEnd()
17805 
    if self.ex is not None:
17806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17807 
      self.ex.write(oprot)
17808 
      oprot.writeFieldEnd()
17809 
    oprot.writeFieldStop()
17810 
    oprot.writeStructEnd()
17811 
 
17812 
  def validate(self):
17813 
    return
17814 
 
17815 
 
17816 
  def __repr__(self):
17817 
    L = ['%s=%r' % (key, value)
17818 
      for key, value in self.__dict__.iteritems()]
17819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17820 
 
17821 
  def __eq__(self, other):
17822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17823 
 
17824 
  def __ne__(self, other):
17825 
    return not (self == other)
4600 varun.gupt 17826 
 
17827 
class getBilledOrdersForVendor_args:
17828 
  """
17829 
  Attributes:
17830 
   - vendorId
17831 
   - billingDateFrom
17832 
   - billingDateTo
17833 
  """
17834 
 
17835 
  thrift_spec = (
17836 
    None, # 0
17837 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17838 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17839 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17840 
  )
17841 
 
17842 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17843 
    self.vendorId = vendorId
17844 
    self.billingDateFrom = billingDateFrom
17845 
    self.billingDateTo = billingDateTo
17846 
 
17847 
  def read(self, iprot):
17848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17850 
      return
17851 
    iprot.readStructBegin()
17852 
    while True:
17853 
      (fname, ftype, fid) = iprot.readFieldBegin()
17854 
      if ftype == TType.STOP:
17855 
        break
17856 
      if fid == 1:
17857 
        if ftype == TType.I64:
17858 
          self.vendorId = iprot.readI64();
17859 
        else:
17860 
          iprot.skip(ftype)
17861 
      elif fid == 2:
17862 
        if ftype == TType.I64:
17863 
          self.billingDateFrom = iprot.readI64();
17864 
        else:
17865 
          iprot.skip(ftype)
17866 
      elif fid == 3:
17867 
        if ftype == TType.I64:
17868 
          self.billingDateTo = iprot.readI64();
17869 
        else:
17870 
          iprot.skip(ftype)
17871 
      else:
17872 
        iprot.skip(ftype)
17873 
      iprot.readFieldEnd()
17874 
    iprot.readStructEnd()
17875 
 
17876 
  def write(self, oprot):
17877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17879 
      return
17880 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17881 
    if self.vendorId is not None:
17882 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17883 
      oprot.writeI64(self.vendorId)
17884 
      oprot.writeFieldEnd()
17885 
    if self.billingDateFrom is not None:
17886 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17887 
      oprot.writeI64(self.billingDateFrom)
17888 
      oprot.writeFieldEnd()
17889 
    if self.billingDateTo is not None:
17890 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17891 
      oprot.writeI64(self.billingDateTo)
17892 
      oprot.writeFieldEnd()
17893 
    oprot.writeFieldStop()
17894 
    oprot.writeStructEnd()
17895 
 
17896 
  def validate(self):
17897 
    return
17898 
 
17899 
 
17900 
  def __repr__(self):
17901 
    L = ['%s=%r' % (key, value)
17902 
      for key, value in self.__dict__.iteritems()]
17903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17904 
 
17905 
  def __eq__(self, other):
17906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17907 
 
17908 
  def __ne__(self, other):
17909 
    return not (self == other)
17910 
 
17911 
class getBilledOrdersForVendor_result:
17912 
  """
17913 
  Attributes:
17914 
   - success
17915 
   - ex
17916 
  """
17917 
 
17918 
  thrift_spec = (
17919 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17920 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17921 
  )
17922 
 
17923 
  def __init__(self, success=None, ex=None,):
17924 
    self.success = success
17925 
    self.ex = ex
17926 
 
17927 
  def read(self, iprot):
17928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17930 
      return
17931 
    iprot.readStructBegin()
17932 
    while True:
17933 
      (fname, ftype, fid) = iprot.readFieldBegin()
17934 
      if ftype == TType.STOP:
17935 
        break
17936 
      if fid == 0:
17937 
        if ftype == TType.LIST:
17938 
          self.success = []
4783 phani.kuma 17939 
          (_etype310, _size307) = iprot.readListBegin()
17940 
          for _i311 in xrange(_size307):
17941 
            _elem312 = Order()
17942 
            _elem312.read(iprot)
17943 
            self.success.append(_elem312)
4600 varun.gupt 17944 
          iprot.readListEnd()
17945 
        else:
17946 
          iprot.skip(ftype)
17947 
      elif fid == 1:
17948 
        if ftype == TType.STRUCT:
17949 
          self.ex = TransactionServiceException()
17950 
          self.ex.read(iprot)
17951 
        else:
17952 
          iprot.skip(ftype)
17953 
      else:
17954 
        iprot.skip(ftype)
17955 
      iprot.readFieldEnd()
17956 
    iprot.readStructEnd()
17957 
 
17958 
  def write(self, oprot):
17959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17961 
      return
17962 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17963 
    if self.success is not None:
17964 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17965 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 17966 
      for iter313 in self.success:
17967 
        iter313.write(oprot)
4600 varun.gupt 17968 
      oprot.writeListEnd()
17969 
      oprot.writeFieldEnd()
17970 
    if self.ex is not None:
17971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17972 
      self.ex.write(oprot)
17973 
      oprot.writeFieldEnd()
17974 
    oprot.writeFieldStop()
17975 
    oprot.writeStructEnd()
17976 
 
17977 
  def validate(self):
17978 
    return
17979 
 
17980 
 
17981 
  def __repr__(self):
17982 
    L = ['%s=%r' % (key, value)
17983 
      for key, value in self.__dict__.iteritems()]
17984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17985 
 
17986 
  def __eq__(self, other):
17987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17988 
 
17989 
  def __ne__(self, other):
17990 
    return not (self == other)
17991 
 
4607 rajveer 17992 
class getSlippedSippingDateOrders_args:
17993 
 
17994 
  thrift_spec = (
17995 
  )
17996 
 
17997 
  def read(self, iprot):
17998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18000 
      return
18001 
    iprot.readStructBegin()
18002 
    while True:
18003 
      (fname, ftype, fid) = iprot.readFieldBegin()
18004 
      if ftype == TType.STOP:
18005 
        break
18006 
      else:
18007 
        iprot.skip(ftype)
18008 
      iprot.readFieldEnd()
18009 
    iprot.readStructEnd()
18010 
 
18011 
  def write(self, oprot):
18012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18014 
      return
18015 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
18016 
    oprot.writeFieldStop()
18017 
    oprot.writeStructEnd()
18018 
 
18019 
  def validate(self):
18020 
    return
18021 
 
18022 
 
18023 
  def __repr__(self):
18024 
    L = ['%s=%r' % (key, value)
18025 
      for key, value in self.__dict__.iteritems()]
18026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18027 
 
18028 
  def __eq__(self, other):
18029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18030 
 
18031 
  def __ne__(self, other):
18032 
    return not (self == other)
18033 
 
18034 
class getSlippedSippingDateOrders_result:
18035 
  """
18036 
  Attributes:
18037 
   - success
18038 
   - ex
18039 
  """
18040 
 
18041 
  thrift_spec = (
18042 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18044 
  )
18045 
 
18046 
  def __init__(self, success=None, ex=None,):
18047 
    self.success = success
18048 
    self.ex = ex
18049 
 
18050 
  def read(self, iprot):
18051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18053 
      return
18054 
    iprot.readStructBegin()
18055 
    while True:
18056 
      (fname, ftype, fid) = iprot.readFieldBegin()
18057 
      if ftype == TType.STOP:
18058 
        break
18059 
      if fid == 0:
18060 
        if ftype == TType.LIST:
18061 
          self.success = []
4783 phani.kuma 18062 
          (_etype317, _size314) = iprot.readListBegin()
18063 
          for _i318 in xrange(_size314):
18064 
            _elem319 = Order()
18065 
            _elem319.read(iprot)
18066 
            self.success.append(_elem319)
4607 rajveer 18067 
          iprot.readListEnd()
18068 
        else:
18069 
          iprot.skip(ftype)
18070 
      elif fid == 1:
18071 
        if ftype == TType.STRUCT:
18072 
          self.ex = TransactionServiceException()
18073 
          self.ex.read(iprot)
18074 
        else:
18075 
          iprot.skip(ftype)
18076 
      else:
18077 
        iprot.skip(ftype)
18078 
      iprot.readFieldEnd()
18079 
    iprot.readStructEnd()
18080 
 
18081 
  def write(self, oprot):
18082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18084 
      return
18085 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18086 
    if self.success is not None:
18087 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18088 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 18089 
      for iter320 in self.success:
18090 
        iter320.write(oprot)
4607 rajveer 18091 
      oprot.writeListEnd()
18092 
      oprot.writeFieldEnd()
18093 
    if self.ex is not None:
18094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18095 
      self.ex.write(oprot)
18096 
      oprot.writeFieldEnd()
18097 
    oprot.writeFieldStop()
18098 
    oprot.writeStructEnd()
18099 
 
18100 
  def validate(self):
18101 
    return
18102 
 
18103 
 
18104 
  def __repr__(self):
18105 
    L = ['%s=%r' % (key, value)
18106 
      for key, value in self.__dict__.iteritems()]
18107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18108 
 
18109 
  def __eq__(self, other):
18110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18111 
 
18112 
  def __ne__(self, other):
18113 
    return not (self == other)
18114 
 
4709 rajveer 18115 
class getCancelledOrders_args:
18116 
  """
18117 
  Attributes:
18118 
   - cancelDateFrom
18119 
   - cancelDateTo
18120 
  """
18121 
 
18122 
  thrift_spec = (
18123 
    None, # 0
18124 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18125 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18126 
  )
18127 
 
18128 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18129 
    self.cancelDateFrom = cancelDateFrom
18130 
    self.cancelDateTo = cancelDateTo
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 1:
18142 
        if ftype == TType.I64:
18143 
          self.cancelDateFrom = iprot.readI64();
18144 
        else:
18145 
          iprot.skip(ftype)
18146 
      elif fid == 2:
18147 
        if ftype == TType.I64:
18148 
          self.cancelDateTo = iprot.readI64();
18149 
        else:
18150 
          iprot.skip(ftype)
18151 
      else:
18152 
        iprot.skip(ftype)
18153 
      iprot.readFieldEnd()
18154 
    iprot.readStructEnd()
18155 
 
18156 
  def write(self, oprot):
18157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18159 
      return
18160 
    oprot.writeStructBegin('getCancelledOrders_args')
18161 
    if self.cancelDateFrom is not None:
18162 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18163 
      oprot.writeI64(self.cancelDateFrom)
18164 
      oprot.writeFieldEnd()
18165 
    if self.cancelDateTo is not None:
18166 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18167 
      oprot.writeI64(self.cancelDateTo)
18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
18186 
 
18187 
class getCancelledOrders_result:
18188 
  """
18189 
  Attributes:
18190 
   - success
18191 
   - ex
18192 
  """
18193 
 
18194 
  thrift_spec = (
18195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18196 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18197 
  )
18198 
 
18199 
  def __init__(self, success=None, ex=None,):
18200 
    self.success = success
18201 
    self.ex = ex
18202 
 
18203 
  def read(self, iprot):
18204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18206 
      return
18207 
    iprot.readStructBegin()
18208 
    while True:
18209 
      (fname, ftype, fid) = iprot.readFieldBegin()
18210 
      if ftype == TType.STOP:
18211 
        break
18212 
      if fid == 0:
18213 
        if ftype == TType.LIST:
18214 
          self.success = []
4783 phani.kuma 18215 
          (_etype324, _size321) = iprot.readListBegin()
18216 
          for _i325 in xrange(_size321):
18217 
            _elem326 = Order()
18218 
            _elem326.read(iprot)
18219 
            self.success.append(_elem326)
4709 rajveer 18220 
          iprot.readListEnd()
18221 
        else:
18222 
          iprot.skip(ftype)
18223 
      elif fid == 1:
18224 
        if ftype == TType.STRUCT:
18225 
          self.ex = TransactionServiceException()
18226 
          self.ex.read(iprot)
18227 
        else:
18228 
          iprot.skip(ftype)
18229 
      else:
18230 
        iprot.skip(ftype)
18231 
      iprot.readFieldEnd()
18232 
    iprot.readStructEnd()
18233 
 
18234 
  def write(self, oprot):
18235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18237 
      return
18238 
    oprot.writeStructBegin('getCancelledOrders_result')
18239 
    if self.success is not None:
18240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18241 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 18242 
      for iter327 in self.success:
18243 
        iter327.write(oprot)
4709 rajveer 18244 
      oprot.writeListEnd()
18245 
      oprot.writeFieldEnd()
18246 
    if self.ex is not None:
18247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18248 
      self.ex.write(oprot)
18249 
      oprot.writeFieldEnd()
18250 
    oprot.writeFieldStop()
18251 
    oprot.writeStructEnd()
18252 
 
18253 
  def validate(self):
18254 
    return
18255 
 
18256 
 
18257 
  def __repr__(self):
18258 
    L = ['%s=%r' % (key, value)
18259 
      for key, value in self.__dict__.iteritems()]
18260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18261 
 
18262 
  def __eq__(self, other):
18263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18264 
 
18265 
  def __ne__(self, other):
18266 
    return not (self == other)
18267 
 
4600 varun.gupt 18268 
class saveBluedartSettlements_args:
18269 
  """
18270 
  Attributes:
18271 
   - mapAWBAndAmount
18272 
  """
18273 
 
18274 
  thrift_spec = (
18275 
    None, # 0
18276 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18277 
  )
18278 
 
18279 
  def __init__(self, mapAWBAndAmount=None,):
18280 
    self.mapAWBAndAmount = mapAWBAndAmount
18281 
 
18282 
  def read(self, iprot):
18283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18285 
      return
18286 
    iprot.readStructBegin()
18287 
    while True:
18288 
      (fname, ftype, fid) = iprot.readFieldBegin()
18289 
      if ftype == TType.STOP:
18290 
        break
18291 
      if fid == 1:
18292 
        if ftype == TType.MAP:
18293 
          self.mapAWBAndAmount = {}
4783 phani.kuma 18294 
          (_ktype329, _vtype330, _size328 ) = iprot.readMapBegin()
18295 
          for _i332 in xrange(_size328):
18296 
            _key333 = iprot.readI64();
18297 
            _val334 = iprot.readDouble();
18298 
            self.mapAWBAndAmount[_key333] = _val334
4600 varun.gupt 18299 
          iprot.readMapEnd()
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      else:
18303 
        iprot.skip(ftype)
18304 
      iprot.readFieldEnd()
18305 
    iprot.readStructEnd()
18306 
 
18307 
  def write(self, oprot):
18308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18310 
      return
18311 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18312 
    if self.mapAWBAndAmount is not None:
18313 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18314 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4783 phani.kuma 18315 
      for kiter335,viter336 in self.mapAWBAndAmount.items():
18316 
        oprot.writeI64(kiter335)
18317 
        oprot.writeDouble(viter336)
4600 varun.gupt 18318 
      oprot.writeMapEnd()
18319 
      oprot.writeFieldEnd()
18320 
    oprot.writeFieldStop()
18321 
    oprot.writeStructEnd()
18322 
 
18323 
  def validate(self):
18324 
    return
18325 
 
18326 
 
18327 
  def __repr__(self):
18328 
    L = ['%s=%r' % (key, value)
18329 
      for key, value in self.__dict__.iteritems()]
18330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18331 
 
18332 
  def __eq__(self, other):
18333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18334 
 
18335 
  def __ne__(self, other):
18336 
    return not (self == other)
18337 
 
18338 
class saveBluedartSettlements_result:
18339 
  """
18340 
  Attributes:
18341 
   - ex
18342 
  """
18343 
 
18344 
  thrift_spec = (
18345 
    None, # 0
18346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18347 
  )
18348 
 
18349 
  def __init__(self, ex=None,):
18350 
    self.ex = ex
18351 
 
18352 
  def read(self, iprot):
18353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18355 
      return
18356 
    iprot.readStructBegin()
18357 
    while True:
18358 
      (fname, ftype, fid) = iprot.readFieldBegin()
18359 
      if ftype == TType.STOP:
18360 
        break
18361 
      if fid == 1:
18362 
        if ftype == TType.STRUCT:
18363 
          self.ex = TransactionServiceException()
18364 
          self.ex.read(iprot)
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('saveBluedartSettlements_result')
18377 
    if self.ex is not None:
18378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18379 
      self.ex.write(oprot)
18380 
      oprot.writeFieldEnd()
18381 
    oprot.writeFieldStop()
18382 
    oprot.writeStructEnd()
18383 
 
18384 
  def validate(self):
18385 
    return
18386 
 
18387 
 
18388 
  def __repr__(self):
18389 
    L = ['%s=%r' % (key, value)
18390 
      for key, value in self.__dict__.iteritems()]
18391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18392 
 
18393 
  def __eq__(self, other):
18394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18395 
 
18396 
  def __ne__(self, other):
18397 
    return not (self == other)
18398 
 
18399 
class savePaymentSettlements_args:
18400 
  """
18401 
  Attributes:
18402 
   - settlementDate
18403 
   - paymentGatewayId
18404 
   - paymentId
18405 
   - serviceTax
18406 
   - otherCharges
18407 
   - netCollection
18408 
  """
18409 
 
18410 
  thrift_spec = (
18411 
    None, # 0
18412 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18413 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18414 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18415 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18416 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18417 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18418 
  )
18419 
 
18420 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18421 
    self.settlementDate = settlementDate
18422 
    self.paymentGatewayId = paymentGatewayId
18423 
    self.paymentId = paymentId
18424 
    self.serviceTax = serviceTax
18425 
    self.otherCharges = otherCharges
18426 
    self.netCollection = netCollection
18427 
 
18428 
  def read(self, iprot):
18429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18431 
      return
18432 
    iprot.readStructBegin()
18433 
    while True:
18434 
      (fname, ftype, fid) = iprot.readFieldBegin()
18435 
      if ftype == TType.STOP:
18436 
        break
18437 
      if fid == 1:
18438 
        if ftype == TType.I64:
18439 
          self.settlementDate = iprot.readI64();
18440 
        else:
18441 
          iprot.skip(ftype)
18442 
      elif fid == 2:
18443 
        if ftype == TType.I64:
18444 
          self.paymentGatewayId = iprot.readI64();
18445 
        else:
18446 
          iprot.skip(ftype)
18447 
      elif fid == 3:
18448 
        if ftype == TType.I64:
18449 
          self.paymentId = iprot.readI64();
18450 
        else:
18451 
          iprot.skip(ftype)
18452 
      elif fid == 4:
18453 
        if ftype == TType.DOUBLE:
18454 
          self.serviceTax = iprot.readDouble();
18455 
        else:
18456 
          iprot.skip(ftype)
18457 
      elif fid == 5:
18458 
        if ftype == TType.DOUBLE:
18459 
          self.otherCharges = iprot.readDouble();
18460 
        else:
18461 
          iprot.skip(ftype)
18462 
      elif fid == 6:
18463 
        if ftype == TType.DOUBLE:
18464 
          self.netCollection = iprot.readDouble();
18465 
        else:
18466 
          iprot.skip(ftype)
18467 
      else:
18468 
        iprot.skip(ftype)
18469 
      iprot.readFieldEnd()
18470 
    iprot.readStructEnd()
18471 
 
18472 
  def write(self, oprot):
18473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18475 
      return
18476 
    oprot.writeStructBegin('savePaymentSettlements_args')
18477 
    if self.settlementDate is not None:
18478 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18479 
      oprot.writeI64(self.settlementDate)
18480 
      oprot.writeFieldEnd()
18481 
    if self.paymentGatewayId is not None:
18482 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18483 
      oprot.writeI64(self.paymentGatewayId)
18484 
      oprot.writeFieldEnd()
18485 
    if self.paymentId is not None:
18486 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18487 
      oprot.writeI64(self.paymentId)
18488 
      oprot.writeFieldEnd()
18489 
    if self.serviceTax is not None:
18490 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18491 
      oprot.writeDouble(self.serviceTax)
18492 
      oprot.writeFieldEnd()
18493 
    if self.otherCharges is not None:
18494 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18495 
      oprot.writeDouble(self.otherCharges)
18496 
      oprot.writeFieldEnd()
18497 
    if self.netCollection is not None:
18498 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18499 
      oprot.writeDouble(self.netCollection)
18500 
      oprot.writeFieldEnd()
18501 
    oprot.writeFieldStop()
18502 
    oprot.writeStructEnd()
18503 
 
18504 
  def validate(self):
18505 
    return
18506 
 
18507 
 
18508 
  def __repr__(self):
18509 
    L = ['%s=%r' % (key, value)
18510 
      for key, value in self.__dict__.iteritems()]
18511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18512 
 
18513 
  def __eq__(self, other):
18514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18515 
 
18516 
  def __ne__(self, other):
18517 
    return not (self == other)
18518 
 
18519 
class savePaymentSettlements_result:
18520 
  """
18521 
  Attributes:
18522 
   - ex
18523 
  """
18524 
 
18525 
  thrift_spec = (
18526 
    None, # 0
18527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18528 
  )
18529 
 
18530 
  def __init__(self, ex=None,):
18531 
    self.ex = ex
18532 
 
18533 
  def read(self, iprot):
18534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18536 
      return
18537 
    iprot.readStructBegin()
18538 
    while True:
18539 
      (fname, ftype, fid) = iprot.readFieldBegin()
18540 
      if ftype == TType.STOP:
18541 
        break
18542 
      if fid == 1:
18543 
        if ftype == TType.STRUCT:
18544 
          self.ex = TransactionServiceException()
18545 
          self.ex.read(iprot)
18546 
        else:
18547 
          iprot.skip(ftype)
18548 
      else:
18549 
        iprot.skip(ftype)
18550 
      iprot.readFieldEnd()
18551 
    iprot.readStructEnd()
18552 
 
18553 
  def write(self, oprot):
18554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18556 
      return
18557 
    oprot.writeStructBegin('savePaymentSettlements_result')
18558 
    if self.ex is not None:
18559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18560 
      self.ex.write(oprot)
18561 
      oprot.writeFieldEnd()
18562 
    oprot.writeFieldStop()
18563 
    oprot.writeStructEnd()
18564 
 
18565 
  def validate(self):
18566 
    return
18567 
 
18568 
 
18569 
  def __repr__(self):
18570 
    L = ['%s=%r' % (key, value)
18571 
      for key, value in self.__dict__.iteritems()]
18572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18573 
 
18574 
  def __eq__(self, other):
18575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18576 
 
18577 
  def __ne__(self, other):
18578 
    return not (self == other)
18579 
 
18580 
class saveEBSSettlementSummary_args:
18581 
  """
18582 
  Attributes:
18583 
   - settlementId
18584 
   - settlementDate
18585 
   - transactionDateFrom
18586 
   - transactionDateTo
18587 
   - amount
18588 
  """
18589 
 
18590 
  thrift_spec = (
18591 
    None, # 0
18592 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18593 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18594 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18595 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18596 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18597 
  )
18598 
 
18599 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18600 
    self.settlementId = settlementId
18601 
    self.settlementDate = settlementDate
18602 
    self.transactionDateFrom = transactionDateFrom
18603 
    self.transactionDateTo = transactionDateTo
18604 
    self.amount = amount
18605 
 
18606 
  def read(self, iprot):
18607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18609 
      return
18610 
    iprot.readStructBegin()
18611 
    while True:
18612 
      (fname, ftype, fid) = iprot.readFieldBegin()
18613 
      if ftype == TType.STOP:
18614 
        break
18615 
      if fid == 1:
18616 
        if ftype == TType.I64:
18617 
          self.settlementId = iprot.readI64();
18618 
        else:
18619 
          iprot.skip(ftype)
18620 
      elif fid == 2:
18621 
        if ftype == TType.I64:
18622 
          self.settlementDate = iprot.readI64();
18623 
        else:
18624 
          iprot.skip(ftype)
18625 
      elif fid == 3:
18626 
        if ftype == TType.I64:
18627 
          self.transactionDateFrom = iprot.readI64();
18628 
        else:
18629 
          iprot.skip(ftype)
18630 
      elif fid == 4:
18631 
        if ftype == TType.I64:
18632 
          self.transactionDateTo = iprot.readI64();
18633 
        else:
18634 
          iprot.skip(ftype)
18635 
      elif fid == 5:
18636 
        if ftype == TType.DOUBLE:
18637 
          self.amount = iprot.readDouble();
18638 
        else:
18639 
          iprot.skip(ftype)
18640 
      else:
18641 
        iprot.skip(ftype)
18642 
      iprot.readFieldEnd()
18643 
    iprot.readStructEnd()
18644 
 
18645 
  def write(self, oprot):
18646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18648 
      return
18649 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18650 
    if self.settlementId is not None:
18651 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18652 
      oprot.writeI64(self.settlementId)
18653 
      oprot.writeFieldEnd()
18654 
    if self.settlementDate is not None:
18655 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18656 
      oprot.writeI64(self.settlementDate)
18657 
      oprot.writeFieldEnd()
18658 
    if self.transactionDateFrom is not None:
18659 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18660 
      oprot.writeI64(self.transactionDateFrom)
18661 
      oprot.writeFieldEnd()
18662 
    if self.transactionDateTo is not None:
18663 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18664 
      oprot.writeI64(self.transactionDateTo)
18665 
      oprot.writeFieldEnd()
18666 
    if self.amount is not None:
18667 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18668 
      oprot.writeDouble(self.amount)
18669 
      oprot.writeFieldEnd()
18670 
    oprot.writeFieldStop()
18671 
    oprot.writeStructEnd()
18672 
 
18673 
  def validate(self):
18674 
    return
18675 
 
18676 
 
18677 
  def __repr__(self):
18678 
    L = ['%s=%r' % (key, value)
18679 
      for key, value in self.__dict__.iteritems()]
18680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18681 
 
18682 
  def __eq__(self, other):
18683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18684 
 
18685 
  def __ne__(self, other):
18686 
    return not (self == other)
18687 
 
18688 
class saveEBSSettlementSummary_result:
18689 
  """
18690 
  Attributes:
18691 
   - ex
18692 
  """
18693 
 
18694 
  thrift_spec = (
18695 
    None, # 0
18696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18697 
  )
18698 
 
18699 
  def __init__(self, ex=None,):
18700 
    self.ex = ex
18701 
 
18702 
  def read(self, iprot):
18703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18705 
      return
18706 
    iprot.readStructBegin()
18707 
    while True:
18708 
      (fname, ftype, fid) = iprot.readFieldBegin()
18709 
      if ftype == TType.STOP:
18710 
        break
18711 
      if fid == 1:
18712 
        if ftype == TType.STRUCT:
18713 
          self.ex = TransactionServiceException()
18714 
          self.ex.read(iprot)
18715 
        else:
18716 
          iprot.skip(ftype)
18717 
      else:
18718 
        iprot.skip(ftype)
18719 
      iprot.readFieldEnd()
18720 
    iprot.readStructEnd()
18721 
 
18722 
  def write(self, oprot):
18723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18725 
      return
18726 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18727 
    if self.ex is not None:
18728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18729 
      self.ex.write(oprot)
18730 
      oprot.writeFieldEnd()
18731 
    oprot.writeFieldStop()
18732 
    oprot.writeStructEnd()
18733 
 
18734 
  def validate(self):
18735 
    return
18736 
 
18737 
 
18738 
  def __repr__(self):
18739 
    L = ['%s=%r' % (key, value)
18740 
      for key, value in self.__dict__.iteritems()]
18741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18742 
 
18743 
  def __eq__(self, other):
18744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18745 
 
18746 
  def __ne__(self, other):
18747 
    return not (self == other)
18748 
 
18749 
class getSettlementForPaymentId_args:
18750 
  """
18751 
  Attributes:
18752 
   - paymentId
18753 
  """
18754 
 
18755 
  thrift_spec = (
18756 
    None, # 0
18757 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18758 
  )
18759 
 
18760 
  def __init__(self, paymentId=None,):
18761 
    self.paymentId = paymentId
18762 
 
18763 
  def read(self, iprot):
18764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18766 
      return
18767 
    iprot.readStructBegin()
18768 
    while True:
18769 
      (fname, ftype, fid) = iprot.readFieldBegin()
18770 
      if ftype == TType.STOP:
18771 
        break
18772 
      if fid == 1:
18773 
        if ftype == TType.I64:
18774 
          self.paymentId = iprot.readI64();
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      else:
18778 
        iprot.skip(ftype)
18779 
      iprot.readFieldEnd()
18780 
    iprot.readStructEnd()
18781 
 
18782 
  def write(self, oprot):
18783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18785 
      return
18786 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18787 
    if self.paymentId is not None:
18788 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18789 
      oprot.writeI64(self.paymentId)
18790 
      oprot.writeFieldEnd()
18791 
    oprot.writeFieldStop()
18792 
    oprot.writeStructEnd()
18793 
 
18794 
  def validate(self):
18795 
    return
18796 
 
18797 
 
18798 
  def __repr__(self):
18799 
    L = ['%s=%r' % (key, value)
18800 
      for key, value in self.__dict__.iteritems()]
18801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18802 
 
18803 
  def __eq__(self, other):
18804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18805 
 
18806 
  def __ne__(self, other):
18807 
    return not (self == other)
18808 
 
18809 
class getSettlementForPaymentId_result:
18810 
  """
18811 
  Attributes:
18812 
   - success
18813 
   - ex
18814 
  """
18815 
 
18816 
  thrift_spec = (
18817 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18819 
  )
18820 
 
18821 
  def __init__(self, success=None, ex=None,):
18822 
    self.success = success
18823 
    self.ex = ex
18824 
 
18825 
  def read(self, iprot):
18826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18828 
      return
18829 
    iprot.readStructBegin()
18830 
    while True:
18831 
      (fname, ftype, fid) = iprot.readFieldBegin()
18832 
      if ftype == TType.STOP:
18833 
        break
18834 
      if fid == 0:
18835 
        if ftype == TType.STRUCT:
18836 
          self.success = PaymentSettlement()
18837 
          self.success.read(iprot)
18838 
        else:
18839 
          iprot.skip(ftype)
18840 
      elif fid == 1:
18841 
        if ftype == TType.STRUCT:
18842 
          self.ex = TransactionServiceException()
18843 
          self.ex.read(iprot)
18844 
        else:
18845 
          iprot.skip(ftype)
18846 
      else:
18847 
        iprot.skip(ftype)
18848 
      iprot.readFieldEnd()
18849 
    iprot.readStructEnd()
18850 
 
18851 
  def write(self, oprot):
18852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18854 
      return
18855 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18856 
    if self.success is not None:
18857 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18858 
      self.success.write(oprot)
18859 
      oprot.writeFieldEnd()
18860 
    if self.ex is not None:
18861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18862 
      self.ex.write(oprot)
18863 
      oprot.writeFieldEnd()
18864 
    oprot.writeFieldStop()
18865 
    oprot.writeStructEnd()
18866 
 
18867 
  def validate(self):
18868 
    return
18869 
 
18870 
 
18871 
  def __repr__(self):
18872 
    L = ['%s=%r' % (key, value)
18873 
      for key, value in self.__dict__.iteritems()]
18874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18875 
 
18876 
  def __eq__(self, other):
18877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18878 
 
18879 
  def __ne__(self, other):
18880 
    return not (self == other)
18881 
 
18882 
class getEBSSettlementSummaries_args:
18883 
 
18884 
  thrift_spec = (
18885 
  )
18886 
 
18887 
  def read(self, iprot):
18888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18890 
      return
18891 
    iprot.readStructBegin()
18892 
    while True:
18893 
      (fname, ftype, fid) = iprot.readFieldBegin()
18894 
      if ftype == TType.STOP:
18895 
        break
18896 
      else:
18897 
        iprot.skip(ftype)
18898 
      iprot.readFieldEnd()
18899 
    iprot.readStructEnd()
18900 
 
18901 
  def write(self, oprot):
18902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18904 
      return
18905 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18906 
    oprot.writeFieldStop()
18907 
    oprot.writeStructEnd()
18908 
 
18909 
  def validate(self):
18910 
    return
18911 
 
18912 
 
18913 
  def __repr__(self):
18914 
    L = ['%s=%r' % (key, value)
18915 
      for key, value in self.__dict__.iteritems()]
18916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18917 
 
18918 
  def __eq__(self, other):
18919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18920 
 
18921 
  def __ne__(self, other):
18922 
    return not (self == other)
18923 
 
18924 
class getEBSSettlementSummaries_result:
18925 
  """
18926 
  Attributes:
18927 
   - success
18928 
   - ex
18929 
  """
18930 
 
18931 
  thrift_spec = (
18932 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18934 
  )
18935 
 
18936 
  def __init__(self, success=None, ex=None,):
18937 
    self.success = success
18938 
    self.ex = ex
18939 
 
18940 
  def read(self, iprot):
18941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18943 
      return
18944 
    iprot.readStructBegin()
18945 
    while True:
18946 
      (fname, ftype, fid) = iprot.readFieldBegin()
18947 
      if ftype == TType.STOP:
18948 
        break
18949 
      if fid == 0:
18950 
        if ftype == TType.MAP:
18951 
          self.success = {}
4783 phani.kuma 18952 
          (_ktype338, _vtype339, _size337 ) = iprot.readMapBegin()
18953 
          for _i341 in xrange(_size337):
18954 
            _key342 = iprot.readI64();
18955 
            _val343 = iprot.readString();
18956 
            self.success[_key342] = _val343
4600 varun.gupt 18957 
          iprot.readMapEnd()
18958 
        else:
18959 
          iprot.skip(ftype)
18960 
      elif fid == 1:
18961 
        if ftype == TType.STRUCT:
18962 
          self.ex = TransactionServiceException()
18963 
          self.ex.read(iprot)
18964 
        else:
18965 
          iprot.skip(ftype)
18966 
      else:
18967 
        iprot.skip(ftype)
18968 
      iprot.readFieldEnd()
18969 
    iprot.readStructEnd()
18970 
 
18971 
  def write(self, oprot):
18972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18974 
      return
18975 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18976 
    if self.success is not None:
18977 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18978 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4783 phani.kuma 18979 
      for kiter344,viter345 in self.success.items():
18980 
        oprot.writeI64(kiter344)
18981 
        oprot.writeString(viter345)
4600 varun.gupt 18982 
      oprot.writeMapEnd()
18983 
      oprot.writeFieldEnd()
18984 
    if self.ex is not None:
18985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18986 
      self.ex.write(oprot)
18987 
      oprot.writeFieldEnd()
18988 
    oprot.writeFieldStop()
18989 
    oprot.writeStructEnd()
18990 
 
18991 
  def validate(self):
18992 
    return
18993 
 
18994 
 
18995 
  def __repr__(self):
18996 
    L = ['%s=%r' % (key, value)
18997 
      for key, value in self.__dict__.iteritems()]
18998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18999 
 
19000 
  def __eq__(self, other):
19001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19002 
 
19003 
  def __ne__(self, other):
19004 
    return not (self == other)
19005 
 
19006 
class markEBSSettlementUploaded_args:
19007 
  """
19008 
  Attributes:
19009 
   - settlementId
19010 
  """
19011 
 
19012 
  thrift_spec = (
19013 
    None, # 0
19014 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19015 
  )
19016 
 
19017 
  def __init__(self, settlementId=None,):
19018 
    self.settlementId = settlementId
19019 
 
19020 
  def read(self, iprot):
19021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19023 
      return
19024 
    iprot.readStructBegin()
19025 
    while True:
19026 
      (fname, ftype, fid) = iprot.readFieldBegin()
19027 
      if ftype == TType.STOP:
19028 
        break
19029 
      if fid == 1:
19030 
        if ftype == TType.I64:
19031 
          self.settlementId = iprot.readI64();
19032 
        else:
19033 
          iprot.skip(ftype)
19034 
      else:
19035 
        iprot.skip(ftype)
19036 
      iprot.readFieldEnd()
19037 
    iprot.readStructEnd()
19038 
 
19039 
  def write(self, oprot):
19040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19042 
      return
19043 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
19044 
    if self.settlementId is not None:
19045 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19046 
      oprot.writeI64(self.settlementId)
19047 
      oprot.writeFieldEnd()
19048 
    oprot.writeFieldStop()
19049 
    oprot.writeStructEnd()
19050 
 
19051 
  def validate(self):
19052 
    return
19053 
 
19054 
 
19055 
  def __repr__(self):
19056 
    L = ['%s=%r' % (key, value)
19057 
      for key, value in self.__dict__.iteritems()]
19058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19059 
 
19060 
  def __eq__(self, other):
19061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19062 
 
19063 
  def __ne__(self, other):
19064 
    return not (self == other)
19065 
 
19066 
class markEBSSettlementUploaded_result:
19067 
  """
19068 
  Attributes:
19069 
   - ex
19070 
  """
19071 
 
19072 
  thrift_spec = (
19073 
    None, # 0
19074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19075 
  )
19076 
 
19077 
  def __init__(self, ex=None,):
19078 
    self.ex = ex
19079 
 
19080 
  def read(self, iprot):
19081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19083 
      return
19084 
    iprot.readStructBegin()
19085 
    while True:
19086 
      (fname, ftype, fid) = iprot.readFieldBegin()
19087 
      if ftype == TType.STOP:
19088 
        break
19089 
      if fid == 1:
19090 
        if ftype == TType.STRUCT:
19091 
          self.ex = TransactionServiceException()
19092 
          self.ex.read(iprot)
19093 
        else:
19094 
          iprot.skip(ftype)
19095 
      else:
19096 
        iprot.skip(ftype)
19097 
      iprot.readFieldEnd()
19098 
    iprot.readStructEnd()
19099 
 
19100 
  def write(self, oprot):
19101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19103 
      return
19104 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19105 
    if self.ex is not None:
19106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19107 
      self.ex.write(oprot)
19108 
      oprot.writeFieldEnd()
19109 
    oprot.writeFieldStop()
19110 
    oprot.writeStructEnd()
19111 
 
19112 
  def validate(self):
19113 
    return
19114 
 
19115 
 
19116 
  def __repr__(self):
19117 
    L = ['%s=%r' % (key, value)
19118 
      for key, value in self.__dict__.iteritems()]
19119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19120 
 
19121 
  def __eq__(self, other):
19122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19123 
 
19124 
  def __ne__(self, other):
19125 
    return not (self == other)
19126 
 
19127 
class getEBSSettlementDate_args:
19128 
  """
19129 
  Attributes:
19130 
   - settlementId
19131 
  """
19132 
 
19133 
  thrift_spec = (
19134 
    None, # 0
19135 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19136 
  )
19137 
 
19138 
  def __init__(self, settlementId=None,):
19139 
    self.settlementId = settlementId
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      if fid == 1:
19151 
        if ftype == TType.I64:
19152 
          self.settlementId = iprot.readI64();
19153 
        else:
19154 
          iprot.skip(ftype)
19155 
      else:
19156 
        iprot.skip(ftype)
19157 
      iprot.readFieldEnd()
19158 
    iprot.readStructEnd()
19159 
 
19160 
  def write(self, oprot):
19161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19163 
      return
19164 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19165 
    if self.settlementId is not None:
19166 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19167 
      oprot.writeI64(self.settlementId)
19168 
      oprot.writeFieldEnd()
19169 
    oprot.writeFieldStop()
19170 
    oprot.writeStructEnd()
19171 
 
19172 
  def validate(self):
19173 
    return
19174 
 
19175 
 
19176 
  def __repr__(self):
19177 
    L = ['%s=%r' % (key, value)
19178 
      for key, value in self.__dict__.iteritems()]
19179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19180 
 
19181 
  def __eq__(self, other):
19182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19183 
 
19184 
  def __ne__(self, other):
19185 
    return not (self == other)
19186 
 
19187 
class getEBSSettlementDate_result:
19188 
  """
19189 
  Attributes:
19190 
   - success
19191 
   - ex
19192 
  """
19193 
 
19194 
  thrift_spec = (
19195 
    (0, TType.I64, 'success', None, None, ), # 0
19196 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19197 
  )
19198 
 
19199 
  def __init__(self, success=None, ex=None,):
19200 
    self.success = success
19201 
    self.ex = ex
19202 
 
19203 
  def read(self, iprot):
19204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19206 
      return
19207 
    iprot.readStructBegin()
19208 
    while True:
19209 
      (fname, ftype, fid) = iprot.readFieldBegin()
19210 
      if ftype == TType.STOP:
19211 
        break
19212 
      if fid == 0:
19213 
        if ftype == TType.I64:
19214 
          self.success = iprot.readI64();
19215 
        else:
19216 
          iprot.skip(ftype)
19217 
      elif fid == 1:
19218 
        if ftype == TType.STRUCT:
19219 
          self.ex = TransactionServiceException()
19220 
          self.ex.read(iprot)
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      else:
19224 
        iprot.skip(ftype)
19225 
      iprot.readFieldEnd()
19226 
    iprot.readStructEnd()
19227 
 
19228 
  def write(self, oprot):
19229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19231 
      return
19232 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19233 
    if self.success is not None:
19234 
      oprot.writeFieldBegin('success', TType.I64, 0)
19235 
      oprot.writeI64(self.success)
19236 
      oprot.writeFieldEnd()
19237 
    if self.ex is not None:
19238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19239 
      self.ex.write(oprot)
19240 
      oprot.writeFieldEnd()
19241 
    oprot.writeFieldStop()
19242 
    oprot.writeStructEnd()
19243 
 
19244 
  def validate(self):
19245 
    return
19246 
 
19247 
 
19248 
  def __repr__(self):
19249 
    L = ['%s=%r' % (key, value)
19250 
      for key, value in self.__dict__.iteritems()]
19251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19252 
 
19253 
  def __eq__(self, other):
19254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19255 
 
19256 
  def __ne__(self, other):
19257 
    return not (self == other)
4715 varun.gupt 19258 
 
19259 
class getSettlementsByDate_args:
19260 
  """
19261 
  Attributes:
19262 
   - settlementDateFrom
19263 
   - settlementDateTo
19264 
   - isRefund
19265 
  """
19266 
 
19267 
  thrift_spec = (
19268 
    None, # 0
19269 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19270 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19271 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19272 
  )
19273 
 
19274 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19275 
    self.settlementDateFrom = settlementDateFrom
19276 
    self.settlementDateTo = settlementDateTo
19277 
    self.isRefund = isRefund
19278 
 
19279 
  def read(self, iprot):
19280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19282 
      return
19283 
    iprot.readStructBegin()
19284 
    while True:
19285 
      (fname, ftype, fid) = iprot.readFieldBegin()
19286 
      if ftype == TType.STOP:
19287 
        break
19288 
      if fid == 1:
19289 
        if ftype == TType.I64:
19290 
          self.settlementDateFrom = iprot.readI64();
19291 
        else:
19292 
          iprot.skip(ftype)
19293 
      elif fid == 2:
19294 
        if ftype == TType.I64:
19295 
          self.settlementDateTo = iprot.readI64();
19296 
        else:
19297 
          iprot.skip(ftype)
19298 
      elif fid == 3:
19299 
        if ftype == TType.BOOL:
19300 
          self.isRefund = iprot.readBool();
19301 
        else:
19302 
          iprot.skip(ftype)
19303 
      else:
19304 
        iprot.skip(ftype)
19305 
      iprot.readFieldEnd()
19306 
    iprot.readStructEnd()
19307 
 
19308 
  def write(self, oprot):
19309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19311 
      return
19312 
    oprot.writeStructBegin('getSettlementsByDate_args')
19313 
    if self.settlementDateFrom is not None:
19314 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19315 
      oprot.writeI64(self.settlementDateFrom)
19316 
      oprot.writeFieldEnd()
19317 
    if self.settlementDateTo is not None:
19318 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19319 
      oprot.writeI64(self.settlementDateTo)
19320 
      oprot.writeFieldEnd()
19321 
    if self.isRefund is not None:
19322 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19323 
      oprot.writeBool(self.isRefund)
19324 
      oprot.writeFieldEnd()
19325 
    oprot.writeFieldStop()
19326 
    oprot.writeStructEnd()
19327 
 
19328 
  def validate(self):
19329 
    return
19330 
 
19331 
 
19332 
  def __repr__(self):
19333 
    L = ['%s=%r' % (key, value)
19334 
      for key, value in self.__dict__.iteritems()]
19335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19336 
 
19337 
  def __eq__(self, other):
19338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19339 
 
19340 
  def __ne__(self, other):
19341 
    return not (self == other)
19342 
 
19343 
class getSettlementsByDate_result:
19344 
  """
19345 
  Attributes:
19346 
   - success
19347 
   - ex
19348 
  """
19349 
 
19350 
  thrift_spec = (
19351 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19352 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19353 
  )
19354 
 
19355 
  def __init__(self, success=None, ex=None,):
19356 
    self.success = success
19357 
    self.ex = ex
19358 
 
19359 
  def read(self, iprot):
19360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19362 
      return
19363 
    iprot.readStructBegin()
19364 
    while True:
19365 
      (fname, ftype, fid) = iprot.readFieldBegin()
19366 
      if ftype == TType.STOP:
19367 
        break
19368 
      if fid == 0:
19369 
        if ftype == TType.LIST:
19370 
          self.success = []
4783 phani.kuma 19371 
          (_etype349, _size346) = iprot.readListBegin()
19372 
          for _i350 in xrange(_size346):
19373 
            _elem351 = PaymentSettlement()
19374 
            _elem351.read(iprot)
19375 
            self.success.append(_elem351)
4715 varun.gupt 19376 
          iprot.readListEnd()
19377 
        else:
19378 
          iprot.skip(ftype)
19379 
      elif fid == 1:
19380 
        if ftype == TType.STRUCT:
19381 
          self.ex = TransactionServiceException()
19382 
          self.ex.read(iprot)
19383 
        else:
19384 
          iprot.skip(ftype)
19385 
      else:
19386 
        iprot.skip(ftype)
19387 
      iprot.readFieldEnd()
19388 
    iprot.readStructEnd()
19389 
 
19390 
  def write(self, oprot):
19391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19393 
      return
19394 
    oprot.writeStructBegin('getSettlementsByDate_result')
19395 
    if self.success is not None:
19396 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19397 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4783 phani.kuma 19398 
      for iter352 in self.success:
19399 
        iter352.write(oprot)
4715 varun.gupt 19400 
      oprot.writeListEnd()
19401 
      oprot.writeFieldEnd()
19402 
    if self.ex is not None:
19403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19404 
      self.ex.write(oprot)
19405 
      oprot.writeFieldEnd()
19406 
    oprot.writeFieldStop()
19407 
    oprot.writeStructEnd()
19408 
 
19409 
  def validate(self):
19410 
    return
19411 
 
19412 
 
19413 
  def __repr__(self):
19414 
    L = ['%s=%r' % (key, value)
19415 
      for key, value in self.__dict__.iteritems()]
19416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19417 
 
19418 
  def __eq__(self, other):
19419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19420 
 
19421 
  def __ne__(self, other):
19422 
    return not (self == other)
19423 
 
19424 
class getReshippedOrderIds_args:
19425 
  """
19426 
  Attributes:
19427 
   - orderIds
19428 
  """
19429 
 
19430 
  thrift_spec = (
19431 
    None, # 0
19432 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19433 
  )
19434 
 
19435 
  def __init__(self, orderIds=None,):
19436 
    self.orderIds = orderIds
19437 
 
19438 
  def read(self, iprot):
19439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19441 
      return
19442 
    iprot.readStructBegin()
19443 
    while True:
19444 
      (fname, ftype, fid) = iprot.readFieldBegin()
19445 
      if ftype == TType.STOP:
19446 
        break
19447 
      if fid == 1:
19448 
        if ftype == TType.LIST:
19449 
          self.orderIds = []
4783 phani.kuma 19450 
          (_etype356, _size353) = iprot.readListBegin()
19451 
          for _i357 in xrange(_size353):
19452 
            _elem358 = iprot.readI64();
19453 
            self.orderIds.append(_elem358)
4715 varun.gupt 19454 
          iprot.readListEnd()
19455 
        else:
19456 
          iprot.skip(ftype)
19457 
      else:
19458 
        iprot.skip(ftype)
19459 
      iprot.readFieldEnd()
19460 
    iprot.readStructEnd()
19461 
 
19462 
  def write(self, oprot):
19463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19465 
      return
19466 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19467 
    if self.orderIds is not None:
19468 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19469 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4783 phani.kuma 19470 
      for iter359 in self.orderIds:
19471 
        oprot.writeI64(iter359)
4715 varun.gupt 19472 
      oprot.writeListEnd()
19473 
      oprot.writeFieldEnd()
19474 
    oprot.writeFieldStop()
19475 
    oprot.writeStructEnd()
19476 
 
19477 
  def validate(self):
19478 
    return
19479 
 
19480 
 
19481 
  def __repr__(self):
19482 
    L = ['%s=%r' % (key, value)
19483 
      for key, value in self.__dict__.iteritems()]
19484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19485 
 
19486 
  def __eq__(self, other):
19487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19488 
 
19489 
  def __ne__(self, other):
19490 
    return not (self == other)
19491 
 
19492 
class getReshippedOrderIds_result:
19493 
  """
19494 
  Attributes:
19495 
   - success
19496 
   - ex
19497 
  """
19498 
 
19499 
  thrift_spec = (
19500 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19502 
  )
19503 
 
19504 
  def __init__(self, success=None, ex=None,):
19505 
    self.success = success
19506 
    self.ex = ex
19507 
 
19508 
  def read(self, iprot):
19509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19511 
      return
19512 
    iprot.readStructBegin()
19513 
    while True:
19514 
      (fname, ftype, fid) = iprot.readFieldBegin()
19515 
      if ftype == TType.STOP:
19516 
        break
19517 
      if fid == 0:
19518 
        if ftype == TType.LIST:
19519 
          self.success = []
4783 phani.kuma 19520 
          (_etype363, _size360) = iprot.readListBegin()
19521 
          for _i364 in xrange(_size360):
19522 
            _elem365 = iprot.readI64();
19523 
            self.success.append(_elem365)
4715 varun.gupt 19524 
          iprot.readListEnd()
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      elif fid == 1:
19528 
        if ftype == TType.STRUCT:
19529 
          self.ex = TransactionServiceException()
19530 
          self.ex.read(iprot)
19531 
        else:
19532 
          iprot.skip(ftype)
19533 
      else:
19534 
        iprot.skip(ftype)
19535 
      iprot.readFieldEnd()
19536 
    iprot.readStructEnd()
19537 
 
19538 
  def write(self, oprot):
19539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19541 
      return
19542 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19543 
    if self.success is not None:
19544 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19545 
      oprot.writeListBegin(TType.I64, len(self.success))
4783 phani.kuma 19546 
      for iter366 in self.success:
19547 
        oprot.writeI64(iter366)
4715 varun.gupt 19548 
      oprot.writeListEnd()
19549 
      oprot.writeFieldEnd()
19550 
    if self.ex is not None:
19551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19552 
      self.ex.write(oprot)
19553 
      oprot.writeFieldEnd()
19554 
    oprot.writeFieldStop()
19555 
    oprot.writeStructEnd()
19556 
 
19557 
  def validate(self):
19558 
    return
19559 
 
19560 
 
19561 
  def __repr__(self):
19562 
    L = ['%s=%r' % (key, value)
19563 
      for key, value in self.__dict__.iteritems()]
19564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19565 
 
19566 
  def __eq__(self, other):
19567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19568 
 
19569 
  def __ne__(self, other):
19570 
    return not (self == other)
4757 mandeep.dh 19571 
 
19572 
class updateOrdersAsPORaised_args:
19573 
  """
19574 
  Attributes:
19575 
   - itemIdQuantityMap
19576 
   - purchaseOrderId
19577 
   - warehouseId
19578 
  """
19579 
 
19580 
  thrift_spec = (
19581 
    None, # 0
19582 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19583 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19584 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19585 
  )
19586 
 
19587 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19588 
    self.itemIdQuantityMap = itemIdQuantityMap
19589 
    self.purchaseOrderId = purchaseOrderId
19590 
    self.warehouseId = warehouseId
19591 
 
19592 
  def read(self, iprot):
19593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19595 
      return
19596 
    iprot.readStructBegin()
19597 
    while True:
19598 
      (fname, ftype, fid) = iprot.readFieldBegin()
19599 
      if ftype == TType.STOP:
19600 
        break
19601 
      if fid == 1:
19602 
        if ftype == TType.MAP:
19603 
          self.itemIdQuantityMap = {}
4783 phani.kuma 19604 
          (_ktype368, _vtype369, _size367 ) = iprot.readMapBegin()
19605 
          for _i371 in xrange(_size367):
19606 
            _key372 = iprot.readI64();
19607 
            _val373 = iprot.readI64();
19608 
            self.itemIdQuantityMap[_key372] = _val373
4757 mandeep.dh 19609 
          iprot.readMapEnd()
19610 
        else:
19611 
          iprot.skip(ftype)
19612 
      elif fid == 2:
19613 
        if ftype == TType.I64:
19614 
          self.purchaseOrderId = iprot.readI64();
19615 
        else:
19616 
          iprot.skip(ftype)
19617 
      elif fid == 3:
19618 
        if ftype == TType.I64:
19619 
          self.warehouseId = iprot.readI64();
19620 
        else:
19621 
          iprot.skip(ftype)
19622 
      else:
19623 
        iprot.skip(ftype)
19624 
      iprot.readFieldEnd()
19625 
    iprot.readStructEnd()
19626 
 
19627 
  def write(self, oprot):
19628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19630 
      return
19631 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19632 
    if self.itemIdQuantityMap is not None:
19633 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19634 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4783 phani.kuma 19635 
      for kiter374,viter375 in self.itemIdQuantityMap.items():
19636 
        oprot.writeI64(kiter374)
19637 
        oprot.writeI64(viter375)
4757 mandeep.dh 19638 
      oprot.writeMapEnd()
19639 
      oprot.writeFieldEnd()
19640 
    if self.purchaseOrderId is not None:
19641 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19642 
      oprot.writeI64(self.purchaseOrderId)
19643 
      oprot.writeFieldEnd()
19644 
    if self.warehouseId is not None:
19645 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19646 
      oprot.writeI64(self.warehouseId)
19647 
      oprot.writeFieldEnd()
19648 
    oprot.writeFieldStop()
19649 
    oprot.writeStructEnd()
19650 
 
19651 
  def validate(self):
19652 
    return
19653 
 
19654 
 
19655 
  def __repr__(self):
19656 
    L = ['%s=%r' % (key, value)
19657 
      for key, value in self.__dict__.iteritems()]
19658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19659 
 
19660 
  def __eq__(self, other):
19661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19662 
 
19663 
  def __ne__(self, other):
19664 
    return not (self == other)
19665 
 
19666 
class updateOrdersAsPORaised_result:
19667 
  """
19668 
  Attributes:
19669 
   - ex
19670 
  """
19671 
 
19672 
  thrift_spec = (
19673 
    None, # 0
19674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19675 
  )
19676 
 
19677 
  def __init__(self, ex=None,):
19678 
    self.ex = ex
19679 
 
19680 
  def read(self, iprot):
19681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19683 
      return
19684 
    iprot.readStructBegin()
19685 
    while True:
19686 
      (fname, ftype, fid) = iprot.readFieldBegin()
19687 
      if ftype == TType.STOP:
19688 
        break
19689 
      if fid == 1:
19690 
        if ftype == TType.STRUCT:
19691 
          self.ex = TransactionServiceException()
19692 
          self.ex.read(iprot)
19693 
        else:
19694 
          iprot.skip(ftype)
19695 
      else:
19696 
        iprot.skip(ftype)
19697 
      iprot.readFieldEnd()
19698 
    iprot.readStructEnd()
19699 
 
19700 
  def write(self, oprot):
19701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19703 
      return
19704 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19705 
    if self.ex is not None:
19706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19707 
      self.ex.write(oprot)
19708 
      oprot.writeFieldEnd()
19709 
    oprot.writeFieldStop()
19710 
    oprot.writeStructEnd()
19711 
 
19712 
  def validate(self):
19713 
    return
19714 
 
19715 
 
19716 
  def __repr__(self):
19717 
    L = ['%s=%r' % (key, value)
19718 
      for key, value in self.__dict__.iteritems()]
19719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19720 
 
19721 
  def __eq__(self, other):
19722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19723 
 
19724 
  def __ne__(self, other):
19725 
    return not (self == other)