Subversion Repositories SmartDukaan

Rev

Rev 4757 | Rev 4783 | 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 
 
2536 chandransh 434 
  def toggleDOAFlag(self, orderId):
435 
    """
436 
    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.
437 
    Returns the final flag status.
438 
    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 439 
 
2536 chandransh 440 
    Parameters:
441 
     - orderId
442 
    """
443 
    pass
1886 ankur.sing 444 
 
4712 rajveer 445 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
446 
    """
447 
    Parameters:
448 
     - orderId
449 
     - deliveryTimestamp
450 
     - receiver
451 
    """
452 
    pass
453 
 
4454 rajveer 454 
  def markOrderDoaRequestReceived(self, orderId):
455 
    """
456 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
457 
 
458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
462 
 
463 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
464 
    """
465 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
466 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
467 
 
468 
    Parameters:
469 
     - orderId
470 
     - isAuthorized
471 
    """
472 
    pass
473 
 
4488 rajveer 474 
  def markOrderReturnRequestReceived(self, orderId):
475 
    """
476 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
477 
 
478 
    Parameters:
479 
     - orderId
480 
    """
481 
    pass
482 
 
483 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
484 
    """
485 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
486 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
487 
 
488 
    Parameters:
489 
     - orderId
490 
     - isAuthorized
491 
    """
492 
    pass
493 
 
4579 rajveer 494 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 495 
    """
496 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 497 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
498 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 499 
    For any other status, it returns false.
500 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 501 
 
2536 chandransh 502 
    Parameters:
503 
     - orderId
4579 rajveer 504 
     - providerId
2536 chandransh 505 
    """
506 
    pass
507 
 
4602 rajveer 508 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 509 
    """
4452 rajveer 510 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 511 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
512 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
513 
    	3. Returns true
2591 chandransh 514 
    If the order is in any other status, it returns false.
2536 chandransh 515 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 516 
 
2536 chandransh 517 
    Parameters:
518 
     - orderId
519 
     - pickupNumber
4602 rajveer 520 
     - providerId
2536 chandransh 521 
    """
522 
    pass
523 
 
2764 chandransh 524 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
525 
    """
526 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
527 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 528 
 
2764 chandransh 529 
    Parameters:
530 
     - providerId
531 
     - pickupDetails
532 
    """
533 
    pass
534 
 
4741 phani.kuma 535 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
536 
    """
537 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
538 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
539 
 
540 
    Parameters:
541 
     - providerId
542 
     - pickupDetails
543 
    """
544 
    pass
545 
 
4479 rajveer 546 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 547 
    """
4452 rajveer 548 
    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 549 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 550 
    If the order is in any other state, it returns false.
551 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 552 
 
2591 chandransh 553 
    Parameters:
554 
     - orderId
4479 rajveer 555 
     - receiveCondition
2591 chandransh 556 
    """
557 
    pass
2536 chandransh 558 
 
2591 chandransh 559 
  def validateDoa(self, orderId, isValid):
560 
    """
4452 rajveer 561 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 562 
    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 563 
    If the order is in any other state, it returns false.
564 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 565 
 
2591 chandransh 566 
    Parameters:
567 
     - orderId
568 
     - isValid
569 
    """
570 
    pass
571 
 
4495 rajveer 572 
  def validateReturnProduct(self, orderId, isUsable):
573 
    """
574 
    Parameters:
575 
     - orderId
576 
     - isUsable
577 
    """
578 
    pass
579 
 
2616 chandransh 580 
  def reshipOrder(self, orderId):
581 
    """
4484 rajveer 582 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 583 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 584 
    	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 585 
 
586 
    If the order is in DOA_CERT_VALID state, it does the following:
587 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
588 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 589 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 590 
 
2616 chandransh 591 
    Returns the id of the newly created order.
3431 rajveer 592 
 
2616 chandransh 593 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 594 
 
2616 chandransh 595 
    Parameters:
596 
     - orderId
597 
    """
598 
    pass
2591 chandransh 599 
 
3226 chandransh 600 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 601 
    """
4484 rajveer 602 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 603 
    	1. Creates a refund request for batch processing.
604 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 605 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 606 
 
2616 chandransh 607 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
608 
    	1. Creates a refund request for batch processing.
3226 chandransh 609 
    	2. Cancels the reservation of the item in the warehouse.
610 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 611 
 
3226 chandransh 612 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
613 
    	1. Cancels the reservation of the item in the warehouse.
614 
    	2. Marks the current order as CANCELED.
615 
 
616 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
617 
 
2616 chandransh 618 
    Returns True if it is successful, False otherwise.
3431 rajveer 619 
 
2616 chandransh 620 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 621 
 
2616 chandransh 622 
    Parameters:
623 
     - orderId
3226 chandransh 624 
     - refundedBy
625 
     - reason
2616 chandransh 626 
    """
627 
    pass
628 
 
2690 chandransh 629 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
630 
    """
631 
    Get all return orders created between the from and to dates for the given warehouse.
632 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 633 
 
2690 chandransh 634 
    Parameters:
635 
     - warehouseId
636 
     - fromDate
637 
     - toDate
638 
    """
639 
    pass
2616 chandransh 640 
 
2700 chandransh 641 
  def getReturnOrder(self, id):
642 
    """
643 
    Returns the ReturnOrder corresponding to the given id.
644 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 645 
 
2700 chandransh 646 
    Parameters:
647 
     - id
648 
    """
649 
    pass
650 
 
2690 chandransh 651 
  def processReturn(self, returnOrderId):
652 
    """
653 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 654 
 
2690 chandransh 655 
    Parameters:
656 
     - returnOrderId
657 
    """
658 
    pass
659 
 
3451 chandransh 660 
  def updateWeight(self, orderId, weight):
661 
    """
662 
    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 663 
 
3451 chandransh 664 
    Parameters:
665 
     - orderId
666 
     - weight
667 
    """
668 
    pass
669 
 
3469 chandransh 670 
  def changeItem(self, orderId, itemId):
671 
    """
672 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
673 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 674 
 
3469 chandransh 675 
    Parameters:
676 
     - orderId
677 
     - itemId
678 
    """
679 
    pass
680 
 
681 
  def shiftToWarehouse(self, orderId, warehouseId):
682 
    """
683 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
684 
 
685 
    Parameters:
686 
     - orderId
687 
     - warehouseId
688 
    """
689 
    pass
690 
 
4647 rajveer 691 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 692 
    """
693 
    Adds the given delay reason to the given order.
3986 chandransh 694 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 695 
    Raises an exception if no order with the given id can be found.
3469 chandransh 696 
 
3553 chandransh 697 
    Parameters:
698 
     - orderId
699 
     - delayReason
3986 chandransh 700 
     - furtherDelay
4647 rajveer 701 
     - delayReasonText
3553 chandransh 702 
    """
703 
    pass
704 
 
3956 chandransh 705 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
706 
    """
707 
    Marks the COD orders with given AWB nos. as having been processed.
708 
    Updates the captured amount for the corresponding payment.
3553 chandransh 709 
 
3956 chandransh 710 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
711 
    1. There is no order corresponding to an AWB number.
712 
    2. The captured amount for a payment exceeds the total payment.
713 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
714 
 
715 
    Parameters:
716 
     - collectedAmountMap
717 
     - xferBy
718 
     - xferTxnId
719 
     - xferDate
720 
    """
721 
    pass
722 
 
4008 mandeep.dh 723 
  def getTransactionsRequiringExtraProcessing(self, category):
724 
    """
4065 mandeep.dh 725 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 726 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 727 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 728 
 
4008 mandeep.dh 729 
    Parameters:
730 
     - category
731 
    """
732 
    pass
733 
 
734 
  def markTransactionAsProcessed(self, transactionId, category):
735 
    """
736 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 737 
    It essentially deletes the transaction id record for a particular
738 
    processing type category (if present) from DB.
739 
    This is currently used by CRM application.
4008 mandeep.dh 740 
 
741 
    Parameters:
742 
     - transactionId
743 
     - category
744 
    """
745 
    pass
746 
 
4018 chandransh 747 
  def getItemWiseRiskyOrdersCount(self, ):
748 
    """
749 
    Returns a map containing the number of risky orders keyed by item id. A risky order
750 
    is defined as one whose shipping date is about to expire.
751 
    """
752 
    pass
4008 mandeep.dh 753 
 
4295 varun.gupt 754 
  def getOrdersForItemIds(self, itemIds):
755 
    """
756 
    Returns a list of all orders which have items with given id
757 
 
758 
    Parameters:
759 
     - itemIds
760 
    """
761 
    pass
762 
 
4247 rajveer 763 
  def markOrderCancellationRequestReceived(self, orderId):
764 
    """
765 
    Mark order as cancellation request received. If customer sends request of cancellation of
766 
    a particular order, this method will be called. It will just change status of the order
767 
    depending on its current status. It also records the previous status, so that we can move
768 
    back to that status if cancellation request is denied.
4018 chandransh 769 
 
4247 rajveer 770 
    Parameters:
771 
     - orderId
772 
    """
773 
    pass
774 
 
775 
  def markOrderCancellationRequestConfirmed(self, orderId):
776 
    """
777 
    If we decide to to cancel order, CRM will call this method to move the status of order to
778 
    cancellation request confirmed. After this OM will be able to cancel the order.
779 
 
780 
    Parameters:
781 
     - orderId
782 
    """
783 
    pass
784 
 
785 
  def markOrderCancellationRequestDenied(self, orderId):
786 
    """
787 
    If we decide to not to cancel order, we will move the order ro previous status.
788 
 
789 
    Parameters:
790 
     - orderId
791 
    """
792 
    pass
793 
 
4258 rajveer 794 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 795 
    """
4258 rajveer 796 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
797 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 798 
 
799 
    Parameters:
4258 rajveer 800 
     - transactionId
4247 rajveer 801 
    """
802 
    pass
803 
 
4259 anupam.sin 804 
  def refundTransaction(self, transactionId, refundedBy, reason):
805 
    """
806 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
807 
    need to be cancelled
4247 rajveer 808 
 
4259 anupam.sin 809 
    Parameters:
810 
     - transactionId
811 
     - refundedBy
812 
     - reason
813 
    """
814 
    pass
815 
 
4324 mandeep.dh 816 
  def updateShipmentAddress(self, orderId, addressId):
817 
    """
818 
    Updates shipment address of an order. Delivery and shipping date estimates
819 
    etc. are also updated here.
820 
 
821 
    Throws TransactionServiceException in case address change is not
822 
    possible due to certain reasons such as new pincode in address is
823 
    not serviceable etc.
824 
 
825 
    Parameters:
826 
     - orderId
827 
     - addressId
828 
    """
829 
    pass
830 
 
4285 rajveer 831 
  def acceptOrdersForItemId(self, itemId, inventory):
832 
    """
833 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
834 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 835 
 
4285 rajveer 836 
    Parameters:
837 
     - itemId
838 
     - inventory
839 
    """
840 
    pass
841 
 
4369 rajveer 842 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 843 
    """
844 
    Parameters:
845 
     - vendorId
846 
     - itemId
847 
     - quantity
848 
     - estimate
4369 rajveer 849 
     - isReminder
4303 rajveer 850 
    """
851 
    pass
4285 rajveer 852 
 
4369 rajveer 853 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 854 
    """
855 
    Parameters:
856 
     - vendorId
857 
     - itemId
858 
     - quantity
859 
     - estimate
4369 rajveer 860 
     - isReminder
4303 rajveer 861 
    """
862 
    pass
863 
 
4369 rajveer 864 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 865 
    """
866 
    Parameters:
867 
     - vendorId
868 
     - itemId
869 
     - quantity
870 
     - estimate
4369 rajveer 871 
     - isReminder
4303 rajveer 872 
    """
873 
    pass
874 
 
4369 rajveer 875 
  def markOrdersAsTimeout(self, vendorId):
876 
    """
877 
    Parameters:
878 
     - vendorId
879 
    """
880 
    pass
4303 rajveer 881 
 
4662 rajveer 882 
  def markOrderAsLostInTransit(self, orderId):
883 
    """
884 
    Mark order as LOST_IN_TRANSIT
885 
 
886 
    Parameters:
887 
     - orderId
888 
    """
889 
    pass
890 
 
4386 anupam.sin 891 
  def getOrderForAwb(self, awb):
892 
    """
893 
    Returns the order corresponding to an AWB number
4369 rajveer 894 
 
4386 anupam.sin 895 
    Parameters:
896 
     - awb
897 
    """
898 
    pass
899 
 
4506 phani.kuma 900 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
901 
    """
902 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 903 
 
4506 phani.kuma 904 
    Parameters:
905 
     - logistics_provider_id
906 
     - order_status
907 
    """
908 
    pass
909 
 
4600 varun.gupt 910 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
911 
    """
912 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 913 
 
4600 varun.gupt 914 
    Parameters:
915 
     - vendorId
916 
     - billingDateFrom
917 
     - billingDateTo
918 
    """
919 
    pass
920 
 
4607 rajveer 921 
  def getSlippedSippingDateOrders(self, ):
922 
    pass
923 
 
4709 rajveer 924 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
925 
    """
926 
    Parameters:
927 
     - cancelDateFrom
928 
     - cancelDateTo
929 
    """
930 
    pass
931 
 
4600 varun.gupt 932 
  def saveBluedartSettlements(self, mapAWBAndAmount):
933 
    """
934 
    Parameters:
935 
     - mapAWBAndAmount
936 
    """
937 
    pass
938 
 
939 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
940 
    """
941 
    Parameters:
942 
     - settlementDate
943 
     - paymentGatewayId
944 
     - paymentId
945 
     - serviceTax
946 
     - otherCharges
947 
     - netCollection
948 
    """
949 
    pass
950 
 
951 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
952 
    """
953 
    Parameters:
954 
     - settlementId
955 
     - settlementDate
956 
     - transactionDateFrom
957 
     - transactionDateTo
958 
     - amount
959 
    """
960 
    pass
961 
 
962 
  def getSettlementForPaymentId(self, paymentId):
963 
    """
964 
    Parameters:
965 
     - paymentId
966 
    """
967 
    pass
968 
 
969 
  def getEBSSettlementSummaries(self, ):
970 
    pass
971 
 
972 
  def markEBSSettlementUploaded(self, settlementId):
973 
    """
974 
    Parameters:
975 
     - settlementId
976 
    """
977 
    pass
978 
 
979 
  def getEBSSettlementDate(self, settlementId):
980 
    """
981 
    Parameters:
982 
     - settlementId
983 
    """
984 
    pass
985 
 
4715 varun.gupt 986 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
987 
    """
988 
    Parameters:
989 
     - settlementDateFrom
990 
     - settlementDateTo
991 
     - isRefund
992 
    """
993 
    pass
4600 varun.gupt 994 
 
4715 varun.gupt 995 
  def getReshippedOrderIds(self, orderIds):
996 
    """
997 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
998 
 
999 
    Parameters:
1000 
     - orderIds
1001 
    """
1002 
    pass
1003 
 
4757 mandeep.dh 1004 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1005 
    """
1006 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1007 
    the quantities for which the PO is raised.
4715 varun.gupt 1008 
 
4757 mandeep.dh 1009 
    Parameters:
1010 
     - itemIdQuantityMap
1011 
     - purchaseOrderId
1012 
     - warehouseId
1013 
    """
1014 
    pass
1015 
 
1016 
 
3376 rajveer 1017 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1018 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1019 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1020 
 
1021 
  def createTransaction(self, transaction):
1022 
    """
1023 
    Parameters:
1024 
     - transaction
1025 
    """
1026 
    self.send_createTransaction(transaction)
132 ashish 1027 
    return self.recv_createTransaction()
94 ashish 1028 
 
1029 
  def send_createTransaction(self, transaction):
1030 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1031 
    args = createTransaction_args()
1032 
    args.transaction = transaction
1033 
    args.write(self._oprot)
1034 
    self._oprot.writeMessageEnd()
1035 
    self._oprot.trans.flush()
1036 
 
1037 
  def recv_createTransaction(self, ):
1038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1039 
    if mtype == TMessageType.EXCEPTION:
1040 
      x = TApplicationException()
1041 
      x.read(self._iprot)
1042 
      self._iprot.readMessageEnd()
1043 
      raise x
1044 
    result = createTransaction_result()
1045 
    result.read(self._iprot)
1046 
    self._iprot.readMessageEnd()
3431 rajveer 1047 
    if result.success is not None:
132 ashish 1048 
      return result.success
3431 rajveer 1049 
    if result.ex is not None:
94 ashish 1050 
      raise result.ex
132 ashish 1051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1052 
 
1053 
  def getTransaction(self, id):
1054 
    """
1055 
    Parameters:
1056 
     - id
1057 
    """
1058 
    self.send_getTransaction(id)
1059 
    return self.recv_getTransaction()
1060 
 
1061 
  def send_getTransaction(self, id):
1062 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1063 
    args = getTransaction_args()
1064 
    args.id = id
1065 
    args.write(self._oprot)
1066 
    self._oprot.writeMessageEnd()
1067 
    self._oprot.trans.flush()
1068 
 
1069 
  def recv_getTransaction(self, ):
1070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1071 
    if mtype == TMessageType.EXCEPTION:
1072 
      x = TApplicationException()
1073 
      x.read(self._iprot)
1074 
      self._iprot.readMessageEnd()
1075 
      raise x
1076 
    result = getTransaction_result()
1077 
    result.read(self._iprot)
1078 
    self._iprot.readMessageEnd()
3431 rajveer 1079 
    if result.success is not None:
94 ashish 1080 
      return result.success
3431 rajveer 1081 
    if result.ex is not None:
94 ashish 1082 
      raise result.ex
1083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1084 
 
1085 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1086 
    """
1087 
    Parameters:
1088 
     - customerId
1089 
     - from_date
1090 
     - to_date
1091 
     - status
1092 
    """
1093 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1094 
    return self.recv_getTransactionsForCustomer()
1095 
 
1096 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1097 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1098 
    args = getTransactionsForCustomer_args()
1099 
    args.customerId = customerId
1100 
    args.from_date = from_date
1101 
    args.to_date = to_date
1102 
    args.status = status
1103 
    args.write(self._oprot)
1104 
    self._oprot.writeMessageEnd()
1105 
    self._oprot.trans.flush()
1106 
 
1107 
  def recv_getTransactionsForCustomer(self, ):
1108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1109 
    if mtype == TMessageType.EXCEPTION:
1110 
      x = TApplicationException()
1111 
      x.read(self._iprot)
1112 
      self._iprot.readMessageEnd()
1113 
      raise x
1114 
    result = getTransactionsForCustomer_result()
1115 
    result.read(self._iprot)
1116 
    self._iprot.readMessageEnd()
3431 rajveer 1117 
    if result.success is not None:
94 ashish 1118 
      return result.success
3431 rajveer 1119 
    if result.ex is not None:
94 ashish 1120 
      raise result.ex
1121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1122 
 
132 ashish 1123 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1124 
    """
1125 
    Parameters:
1126 
     - shoppingCartId
1127 
    """
1128 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1129 
    return self.recv_getTransactionsForShoppingCartId()
1130 
 
1131 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1132 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1133 
    args = getTransactionsForShoppingCartId_args()
1134 
    args.shoppingCartId = shoppingCartId
1135 
    args.write(self._oprot)
1136 
    self._oprot.writeMessageEnd()
1137 
    self._oprot.trans.flush()
1138 
 
1139 
  def recv_getTransactionsForShoppingCartId(self, ):
1140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1141 
    if mtype == TMessageType.EXCEPTION:
1142 
      x = TApplicationException()
1143 
      x.read(self._iprot)
1144 
      self._iprot.readMessageEnd()
1145 
      raise x
1146 
    result = getTransactionsForShoppingCartId_result()
1147 
    result.read(self._iprot)
1148 
    self._iprot.readMessageEnd()
3431 rajveer 1149 
    if result.success is not None:
132 ashish 1150 
      return result.success
3431 rajveer 1151 
    if result.ex is not None:
132 ashish 1152 
      raise result.ex
1153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1154 
 
94 ashish 1155 
  def getTransactionStatus(self, transactionId):
1156 
    """
1157 
    Parameters:
1158 
     - transactionId
1159 
    """
1160 
    self.send_getTransactionStatus(transactionId)
1161 
    return self.recv_getTransactionStatus()
1162 
 
1163 
  def send_getTransactionStatus(self, transactionId):
1164 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1165 
    args = getTransactionStatus_args()
1166 
    args.transactionId = transactionId
1167 
    args.write(self._oprot)
1168 
    self._oprot.writeMessageEnd()
1169 
    self._oprot.trans.flush()
1170 
 
1171 
  def recv_getTransactionStatus(self, ):
1172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1173 
    if mtype == TMessageType.EXCEPTION:
1174 
      x = TApplicationException()
1175 
      x.read(self._iprot)
1176 
      self._iprot.readMessageEnd()
1177 
      raise x
1178 
    result = getTransactionStatus_result()
1179 
    result.read(self._iprot)
1180 
    self._iprot.readMessageEnd()
3431 rajveer 1181 
    if result.success is not None:
94 ashish 1182 
      return result.success
3431 rajveer 1183 
    if result.ex is not None:
94 ashish 1184 
      raise result.ex
1185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1186 
 
1187 
  def changeTransactionStatus(self, transactionId, status, description):
1188 
    """
1189 
    Parameters:
1190 
     - transactionId
1191 
     - status
1192 
     - description
1193 
    """
1194 
    self.send_changeTransactionStatus(transactionId, status, description)
1195 
    return self.recv_changeTransactionStatus()
1196 
 
1197 
  def send_changeTransactionStatus(self, transactionId, status, description):
1198 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1199 
    args = changeTransactionStatus_args()
1200 
    args.transactionId = transactionId
1201 
    args.status = status
1202 
    args.description = description
1203 
    args.write(self._oprot)
1204 
    self._oprot.writeMessageEnd()
1205 
    self._oprot.trans.flush()
1206 
 
1207 
  def recv_changeTransactionStatus(self, ):
1208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1209 
    if mtype == TMessageType.EXCEPTION:
1210 
      x = TApplicationException()
1211 
      x.read(self._iprot)
1212 
      self._iprot.readMessageEnd()
1213 
      raise x
1214 
    result = changeTransactionStatus_result()
1215 
    result.read(self._iprot)
1216 
    self._iprot.readMessageEnd()
3431 rajveer 1217 
    if result.success is not None:
94 ashish 1218 
      return result.success
3431 rajveer 1219 
    if result.ex is not None:
94 ashish 1220 
      raise result.ex
1221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1222 
 
1398 varun.gupt 1223 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1224 
    """
1225 
    Parameters:
1226 
     - transactionId
1227 
    """
1398 varun.gupt 1228 
    self.send_enqueueTransactionInfoEmail(transactionId)
1229 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1230 
 
1398 varun.gupt 1231 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1232 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1233 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1234 
    args.transactionId = transactionId
1235 
    args.write(self._oprot)
1236 
    self._oprot.writeMessageEnd()
1237 
    self._oprot.trans.flush()
1238 
 
1398 varun.gupt 1239 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1241 
    if mtype == TMessageType.EXCEPTION:
1242 
      x = TApplicationException()
1243 
      x.read(self._iprot)
1244 
      self._iprot.readMessageEnd()
1245 
      raise x
1398 varun.gupt 1246 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1247 
    result.read(self._iprot)
1248 
    self._iprot.readMessageEnd()
3431 rajveer 1249 
    if result.success is not None:
1382 varun.gupt 1250 
      return result.success
3431 rajveer 1251 
    if result.ex is not None:
1382 varun.gupt 1252 
      raise result.ex
1398 varun.gupt 1253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1254 
 
483 rajveer 1255 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1256 
    """
1257 
    Parameters:
483 rajveer 1258 
     - status
1259 
     - from_date
1260 
     - to_date
1261 
     - warehouse_id
94 ashish 1262 
    """
483 rajveer 1263 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1264 
    return self.recv_getAllOrders()
94 ashish 1265 
 
483 rajveer 1266 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1267 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1268 
    args = getAllOrders_args()
1269 
    args.status = status
1270 
    args.from_date = from_date
1271 
    args.to_date = to_date
1272 
    args.warehouse_id = warehouse_id
94 ashish 1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
483 rajveer 1277 
  def recv_getAllOrders(self, ):
94 ashish 1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
483 rajveer 1284 
    result = getAllOrders_result()
94 ashish 1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
3431 rajveer 1287 
    if result.success is not None:
94 ashish 1288 
      return result.success
3431 rajveer 1289 
    if result.ex is not None:
94 ashish 1290 
      raise result.ex
483 rajveer 1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1292 
 
4133 chandransh 1293 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1294 
    """
1295 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1296 
    Pass the status as null and the limit as 0 to ignore them.
1297 
 
1298 
    Parameters:
1299 
     - statuses
1300 
     - offset
1301 
     - limit
1302 
     - warehouse_id
1303 
    """
1304 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1305 
    return self.recv_getOrdersInBatch()
1306 
 
1307 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1308 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1309 
    args = getOrdersInBatch_args()
1310 
    args.statuses = statuses
1311 
    args.offset = offset
1312 
    args.limit = limit
1313 
    args.warehouse_id = warehouse_id
1314 
    args.write(self._oprot)
1315 
    self._oprot.writeMessageEnd()
1316 
    self._oprot.trans.flush()
1317 
 
1318 
  def recv_getOrdersInBatch(self, ):
1319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1320 
    if mtype == TMessageType.EXCEPTION:
1321 
      x = TApplicationException()
1322 
      x.read(self._iprot)
1323 
      self._iprot.readMessageEnd()
1324 
      raise x
1325 
    result = getOrdersInBatch_result()
1326 
    result.read(self._iprot)
1327 
    self._iprot.readMessageEnd()
1328 
    if result.success is not None:
1329 
      return result.success
1330 
    if result.ex is not None:
1331 
      raise result.ex
1332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1333 
 
1334 
  def getOrderCount(self, statuses, warehouseId):
1335 
    """
1336 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1337 
 
1338 
    Parameters:
1339 
     - statuses
1340 
     - warehouseId
1341 
    """
1342 
    self.send_getOrderCount(statuses, warehouseId)
1343 
    return self.recv_getOrderCount()
1344 
 
1345 
  def send_getOrderCount(self, statuses, warehouseId):
1346 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1347 
    args = getOrderCount_args()
1348 
    args.statuses = statuses
1349 
    args.warehouseId = warehouseId
1350 
    args.write(self._oprot)
1351 
    self._oprot.writeMessageEnd()
1352 
    self._oprot.trans.flush()
1353 
 
1354 
  def recv_getOrderCount(self, ):
1355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1356 
    if mtype == TMessageType.EXCEPTION:
1357 
      x = TApplicationException()
1358 
      x.read(self._iprot)
1359 
      self._iprot.readMessageEnd()
1360 
      raise x
1361 
    result = getOrderCount_result()
1362 
    result.read(self._iprot)
1363 
    self._iprot.readMessageEnd()
1364 
    if result.success is not None:
1365 
      return result.success
1366 
    if result.ex is not None:
1367 
      raise result.ex
1368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1369 
 
999 varun.gupt 1370 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1371 
    """
1132 chandransh 1372 
    Returns orders within a range of their billing dates
3431 rajveer 1373 
 
999 varun.gupt 1374 
    Parameters:
1375 
     - status
1376 
     - start_billing_date
1377 
     - end_billing_date
1378 
     - warehouse_id
1379 
    """
1380 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1381 
    return self.recv_getOrdersByBillingDate()
1382 
 
1383 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1384 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1385 
    args = getOrdersByBillingDate_args()
1386 
    args.status = status
1387 
    args.start_billing_date = start_billing_date
1388 
    args.end_billing_date = end_billing_date
1389 
    args.warehouse_id = warehouse_id
1390 
    args.write(self._oprot)
1391 
    self._oprot.writeMessageEnd()
1392 
    self._oprot.trans.flush()
1393 
 
1394 
  def recv_getOrdersByBillingDate(self, ):
1395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1396 
    if mtype == TMessageType.EXCEPTION:
1397 
      x = TApplicationException()
1398 
      x.read(self._iprot)
1399 
      self._iprot.readMessageEnd()
1400 
      raise x
1401 
    result = getOrdersByBillingDate_result()
1402 
    result.read(self._iprot)
1403 
    self._iprot.readMessageEnd()
3431 rajveer 1404 
    if result.success is not None:
999 varun.gupt 1405 
      return result.success
3431 rajveer 1406 
    if result.ex is not None:
999 varun.gupt 1407 
      raise result.ex
1408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1409 
 
3451 chandransh 1410 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1411 
    """
1412 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1413 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1414 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1415 
 
3427 chandransh 1416 
    Parameters:
1417 
     - fromShippingDate
1418 
     - toShippingDate
1419 
     - providerId
1420 
     - warehouseId
3451 chandransh 1421 
     - cod
3427 chandransh 1422 
    """
3451 chandransh 1423 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1424 
    return self.recv_getOrdersByShippingDate()
1425 
 
3451 chandransh 1426 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1427 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1428 
    args = getOrdersByShippingDate_args()
1429 
    args.fromShippingDate = fromShippingDate
1430 
    args.toShippingDate = toShippingDate
1431 
    args.providerId = providerId
1432 
    args.warehouseId = warehouseId
3451 chandransh 1433 
    args.cod = cod
3427 chandransh 1434 
    args.write(self._oprot)
1435 
    self._oprot.writeMessageEnd()
1436 
    self._oprot.trans.flush()
1437 
 
1438 
  def recv_getOrdersByShippingDate(self, ):
1439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1440 
    if mtype == TMessageType.EXCEPTION:
1441 
      x = TApplicationException()
1442 
      x.read(self._iprot)
1443 
      self._iprot.readMessageEnd()
1444 
      raise x
1445 
    result = getOrdersByShippingDate_result()
1446 
    result.read(self._iprot)
1447 
    self._iprot.readMessageEnd()
3431 rajveer 1448 
    if result.success is not None:
3427 chandransh 1449 
      return result.success
3431 rajveer 1450 
    if result.ex is not None:
3427 chandransh 1451 
      raise result.ex
1452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1453 
 
1382 varun.gupt 1454 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1455 
    """
1456 
    Returns order ids for orders which can be returned
3431 rajveer 1457 
 
1382 varun.gupt 1458 
    Parameters:
1459 
     - customer_id
1460 
     - limit
1461 
    """
1462 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1463 
    return self.recv_getReturnableOrdersForCustomer()
1464 
 
1465 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1466 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1467 
    args = getReturnableOrdersForCustomer_args()
1468 
    args.customer_id = customer_id
1469 
    args.limit = limit
1470 
    args.write(self._oprot)
1471 
    self._oprot.writeMessageEnd()
1472 
    self._oprot.trans.flush()
1473 
 
1474 
  def recv_getReturnableOrdersForCustomer(self, ):
1475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1476 
    if mtype == TMessageType.EXCEPTION:
1477 
      x = TApplicationException()
1478 
      x.read(self._iprot)
1479 
      self._iprot.readMessageEnd()
1480 
      raise x
1481 
    result = getReturnableOrdersForCustomer_result()
1482 
    result.read(self._iprot)
1483 
    self._iprot.readMessageEnd()
3431 rajveer 1484 
    if result.success is not None:
1382 varun.gupt 1485 
      return result.success
3431 rajveer 1486 
    if result.ex is not None:
1382 varun.gupt 1487 
      raise result.ex
1488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1489 
 
1490 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1491 
    """
1492 
    Returns order ids for orders which can be cancelled
3431 rajveer 1493 
 
1382 varun.gupt 1494 
    Parameters:
1495 
     - customer_id
1496 
     - limit
1497 
    """
1498 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1499 
    return self.recv_getCancellableOrdersForCustomer()
1500 
 
1501 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1502 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1503 
    args = getCancellableOrdersForCustomer_args()
1504 
    args.customer_id = customer_id
1505 
    args.limit = limit
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getCancellableOrdersForCustomer(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getCancellableOrdersForCustomer_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
1382 varun.gupt 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
1382 varun.gupt 1523 
      raise result.ex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1525 
 
483 rajveer 1526 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1527 
    """
1528 
    Parameters:
483 rajveer 1529 
     - orderId
1530 
     - status
1531 
     - description
94 ashish 1532 
    """
483 rajveer 1533 
    self.send_changeOrderStatus(orderId, status, description)
1534 
    return self.recv_changeOrderStatus()
94 ashish 1535 
 
483 rajveer 1536 
  def send_changeOrderStatus(self, orderId, status, description):
1537 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1538 
    args = changeOrderStatus_args()
1539 
    args.orderId = orderId
1540 
    args.status = status
1541 
    args.description = description
94 ashish 1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
483 rajveer 1546 
  def recv_changeOrderStatus(self, ):
94 ashish 1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
483 rajveer 1553 
    result = changeOrderStatus_result()
94 ashish 1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
3431 rajveer 1556 
    if result.success is not None:
94 ashish 1557 
      return result.success
3431 rajveer 1558 
    if result.ex is not None:
94 ashish 1559 
      raise result.ex
483 rajveer 1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1561 
 
1528 ankur.sing 1562 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1563 
    """
1528 ankur.sing 1564 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1565 
    only user who owns the transaction can view its order details.
3431 rajveer 1566 
 
94 ashish 1567 
    Parameters:
1568 
     - transactionId
1528 ankur.sing 1569 
     - customerId
94 ashish 1570 
    """
1528 ankur.sing 1571 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1572 
    return self.recv_getOrdersForTransaction()
94 ashish 1573 
 
1528 ankur.sing 1574 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1575 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1576 
    args = getOrdersForTransaction_args()
94 ashish 1577 
    args.transactionId = transactionId
1528 ankur.sing 1578 
    args.customerId = customerId
94 ashish 1579 
    args.write(self._oprot)
1580 
    self._oprot.writeMessageEnd()
1581 
    self._oprot.trans.flush()
1582 
 
483 rajveer 1583 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1585 
    if mtype == TMessageType.EXCEPTION:
1586 
      x = TApplicationException()
1587 
      x.read(self._iprot)
1588 
      self._iprot.readMessageEnd()
1589 
      raise x
483 rajveer 1590 
    result = getOrdersForTransaction_result()
94 ashish 1591 
    result.read(self._iprot)
1592 
    self._iprot.readMessageEnd()
3431 rajveer 1593 
    if result.success is not None:
94 ashish 1594 
      return result.success
3431 rajveer 1595 
    if result.ex is not None:
94 ashish 1596 
      raise result.ex
483 rajveer 1597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1598 
 
3014 chandransh 1599 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1600 
    """
3014 chandransh 1601 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1602 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1603 
 
94 ashish 1604 
    Parameters:
483 rajveer 1605 
     - customerId
1606 
     - from_date
1607 
     - to_date
3014 chandransh 1608 
     - statuses
94 ashish 1609 
    """
3014 chandransh 1610 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1611 
    return self.recv_getOrdersForCustomer()
94 ashish 1612 
 
3014 chandransh 1613 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1614 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1615 
    args = getOrdersForCustomer_args()
1616 
    args.customerId = customerId
1617 
    args.from_date = from_date
1618 
    args.to_date = to_date
3014 chandransh 1619 
    args.statuses = statuses
94 ashish 1620 
    args.write(self._oprot)
1621 
    self._oprot.writeMessageEnd()
1622 
    self._oprot.trans.flush()
1623 
 
483 rajveer 1624 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1626 
    if mtype == TMessageType.EXCEPTION:
1627 
      x = TApplicationException()
1628 
      x.read(self._iprot)
1629 
      self._iprot.readMessageEnd()
1630 
      raise x
483 rajveer 1631 
    result = getOrdersForCustomer_result()
94 ashish 1632 
    result.read(self._iprot)
1633 
    self._iprot.readMessageEnd()
3431 rajveer 1634 
    if result.success is not None:
94 ashish 1635 
      return result.success
3431 rajveer 1636 
    if result.ex is not None:
94 ashish 1637 
      raise result.ex
483 rajveer 1638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1639 
 
483 rajveer 1640 
  def createOrder(self, order):
94 ashish 1641 
    """
1642 
    Parameters:
483 rajveer 1643 
     - order
94 ashish 1644 
    """
483 rajveer 1645 
    self.send_createOrder(order)
1646 
    return self.recv_createOrder()
94 ashish 1647 
 
483 rajveer 1648 
  def send_createOrder(self, order):
1649 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1650 
    args = createOrder_args()
1651 
    args.order = order
94 ashish 1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
483 rajveer 1656 
  def recv_createOrder(self, ):
94 ashish 1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
483 rajveer 1663 
    result = createOrder_result()
94 ashish 1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
3431 rajveer 1666 
    if result.success is not None:
94 ashish 1667 
      return result.success
3431 rajveer 1668 
    if result.ex is not None:
94 ashish 1669 
      raise result.ex
483 rajveer 1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1671 
 
483 rajveer 1672 
  def getOrder(self, id):
94 ashish 1673 
    """
1674 
    Parameters:
483 rajveer 1675 
     - id
94 ashish 1676 
    """
483 rajveer 1677 
    self.send_getOrder(id)
1678 
    return self.recv_getOrder()
94 ashish 1679 
 
483 rajveer 1680 
  def send_getOrder(self, id):
1681 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1682 
    args = getOrder_args()
1683 
    args.id = id
94 ashish 1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
483 rajveer 1688 
  def recv_getOrder(self, ):
94 ashish 1689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1690 
    if mtype == TMessageType.EXCEPTION:
1691 
      x = TApplicationException()
1692 
      x.read(self._iprot)
1693 
      self._iprot.readMessageEnd()
1694 
      raise x
483 rajveer 1695 
    result = getOrder_result()
94 ashish 1696 
    result.read(self._iprot)
1697 
    self._iprot.readMessageEnd()
3431 rajveer 1698 
    if result.success is not None:
94 ashish 1699 
      return result.success
3431 rajveer 1700 
    if result.ex is not None:
94 ashish 1701 
      raise result.ex
483 rajveer 1702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1703 
 
483 rajveer 1704 
  def getLineItemsForOrder(self, orderId):
94 ashish 1705 
    """
1706 
    Parameters:
483 rajveer 1707 
     - orderId
94 ashish 1708 
    """
483 rajveer 1709 
    self.send_getLineItemsForOrder(orderId)
1710 
    return self.recv_getLineItemsForOrder()
94 ashish 1711 
 
483 rajveer 1712 
  def send_getLineItemsForOrder(self, orderId):
1713 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1714 
    args = getLineItemsForOrder_args()
1715 
    args.orderId = orderId
94 ashish 1716 
    args.write(self._oprot)
1717 
    self._oprot.writeMessageEnd()
1718 
    self._oprot.trans.flush()
1719 
 
483 rajveer 1720 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1722 
    if mtype == TMessageType.EXCEPTION:
1723 
      x = TApplicationException()
1724 
      x.read(self._iprot)
1725 
      self._iprot.readMessageEnd()
1726 
      raise x
483 rajveer 1727 
    result = getLineItemsForOrder_result()
94 ashish 1728 
    result.read(self._iprot)
1729 
    self._iprot.readMessageEnd()
3431 rajveer 1730 
    if result.success is not None:
94 ashish 1731 
      return result.success
3431 rajveer 1732 
    if result.ex is not None:
94 ashish 1733 
      raise result.ex
483 rajveer 1734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1735 
 
1528 ankur.sing 1736 
  def getOrderForCustomer(self, orderId, customerId):
1737 
    """
1738 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1739 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1740 
 
1528 ankur.sing 1741 
    Parameters:
1742 
     - orderId
1743 
     - customerId
1744 
    """
1745 
    self.send_getOrderForCustomer(orderId, customerId)
1746 
    return self.recv_getOrderForCustomer()
1747 
 
1748 
  def send_getOrderForCustomer(self, orderId, customerId):
1749 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1750 
    args = getOrderForCustomer_args()
1751 
    args.orderId = orderId
1752 
    args.customerId = customerId
1753 
    args.write(self._oprot)
1754 
    self._oprot.writeMessageEnd()
1755 
    self._oprot.trans.flush()
1756 
 
1757 
  def recv_getOrderForCustomer(self, ):
1758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1759 
    if mtype == TMessageType.EXCEPTION:
1760 
      x = TApplicationException()
1761 
      x.read(self._iprot)
1762 
      self._iprot.readMessageEnd()
1763 
      raise x
1764 
    result = getOrderForCustomer_result()
1765 
    result.read(self._iprot)
1766 
    self._iprot.readMessageEnd()
3431 rajveer 1767 
    if result.success is not None:
1528 ankur.sing 1768 
      return result.success
3431 rajveer 1769 
    if result.ex is not None:
1528 ankur.sing 1770 
      raise result.ex
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1772 
 
4444 rajveer 1773 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1774 
    """
1775 
    Parameters:
4394 rajveer 1776 
     - type
4444 rajveer 1777 
     - warehouseId
4394 rajveer 1778 
     - status
1779 
     - timestamp
3064 chandransh 1780 
    """
4444 rajveer 1781 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1782 
    return self.recv_getAlerts()
1783 
 
4444 rajveer 1784 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1785 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1786 
    args = getAlerts_args()
4394 rajveer 1787 
    args.type = type
4444 rajveer 1788 
    args.warehouseId = warehouseId
4394 rajveer 1789 
    args.status = status
1790 
    args.timestamp = timestamp
3064 chandransh 1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getAlerts(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getAlerts_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
3064 chandransh 1806 
      return result.success
1807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1808 
 
4444 rajveer 1809 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1810 
    """
1811 
    Parameters:
1812 
     - type
4444 rajveer 1813 
     - warehouseId
4394 rajveer 1814 
     - description
3064 chandransh 1815 
    """
4444 rajveer 1816 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1817 
    self.recv_addAlert()
3064 chandransh 1818 
 
4444 rajveer 1819 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1820 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1821 
    args = addAlert_args()
3064 chandransh 1822 
    args.type = type
4444 rajveer 1823 
    args.warehouseId = warehouseId
4394 rajveer 1824 
    args.description = description
3064 chandransh 1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
4394 rajveer 1829 
  def recv_addAlert(self, ):
3064 chandransh 1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
4394 rajveer 1836 
    result = addAlert_result()
3064 chandransh 1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
1839 
    return
1840 
 
4444 rajveer 1841 
  def markAlertsAsSeen(self, warehouseId):
1842 
    """
1843 
    Parameters:
1844 
     - warehouseId
1845 
    """
1846 
    self.send_markAlertsAsSeen(warehouseId)
1847 
    self.recv_markAlertsAsSeen()
1848 
 
1849 
  def send_markAlertsAsSeen(self, warehouseId):
1850 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1851 
    args = markAlertsAsSeen_args()
1852 
    args.warehouseId = warehouseId
1853 
    args.write(self._oprot)
1854 
    self._oprot.writeMessageEnd()
1855 
    self._oprot.trans.flush()
1856 
 
1857 
  def recv_markAlertsAsSeen(self, ):
1858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1859 
    if mtype == TMessageType.EXCEPTION:
1860 
      x = TApplicationException()
1861 
      x.read(self._iprot)
1862 
      self._iprot.readMessageEnd()
1863 
      raise x
1864 
    result = markAlertsAsSeen_result()
1865 
    result.read(self._iprot)
1866 
    self._iprot.readMessageEnd()
1867 
    return
1868 
 
3064 chandransh 1869 
  def getValidOrderCount(self, ):
1870 
    """
1871 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1872 
    """
1873 
    self.send_getValidOrderCount()
1874 
    return self.recv_getValidOrderCount()
1875 
 
1876 
  def send_getValidOrderCount(self, ):
1877 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1878 
    args = getValidOrderCount_args()
1879 
    args.write(self._oprot)
1880 
    self._oprot.writeMessageEnd()
1881 
    self._oprot.trans.flush()
1882 
 
1883 
  def recv_getValidOrderCount(self, ):
1884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1885 
    if mtype == TMessageType.EXCEPTION:
1886 
      x = TApplicationException()
1887 
      x.read(self._iprot)
1888 
      self._iprot.readMessageEnd()
1889 
      raise x
1890 
    result = getValidOrderCount_result()
1891 
    result.read(self._iprot)
1892 
    self._iprot.readMessageEnd()
3431 rajveer 1893 
    if result.success is not None:
3064 chandransh 1894 
      return result.success
1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1896 
 
1897 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1898 
    """
1899 
    Returns the number of distinct customers who have done successful transactions
1900 
    """
1901 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1902 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1903 
 
1904 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1905 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1906 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
1911 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
1918 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
3064 chandransh 1922 
      return result.success
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1924 
 
1925 
  def getValidOrdersAmountRange(self, ):
1926 
    """
1927 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1928 
    List contains two values, first minimum amount and second maximum amount.
1929 
    """
1930 
    self.send_getValidOrdersAmountRange()
1931 
    return self.recv_getValidOrdersAmountRange()
1932 
 
1933 
  def send_getValidOrdersAmountRange(self, ):
1934 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1935 
    args = getValidOrdersAmountRange_args()
1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
1940 
  def recv_getValidOrdersAmountRange(self, ):
1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
1947 
    result = getValidOrdersAmountRange_result()
1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
3431 rajveer 1950 
    if result.success is not None:
3064 chandransh 1951 
      return result.success
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1953 
 
1954 
  def getValidOrders(self, limit):
1955 
    """
1956 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1957 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1958 
 
3064 chandransh 1959 
    Parameters:
1960 
     - limit
1961 
    """
1962 
    self.send_getValidOrders(limit)
1963 
    return self.recv_getValidOrders()
1964 
 
1965 
  def send_getValidOrders(self, limit):
1966 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1967 
    args = getValidOrders_args()
1968 
    args.limit = limit
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_getValidOrders(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = getValidOrders_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
3431 rajveer 1983 
    if result.success is not None:
3064 chandransh 1984 
      return result.success
1985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1986 
 
1220 chandransh 1987 
  def batchOrders(self, warehouseId):
1988 
    """
1989 
    Create a batch of all the pending orders for the given warehouse.
1990 
    The returned list is orderd by created_timestamp.
1991 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1992 
 
1220 chandransh 1993 
    Parameters:
1994 
     - warehouseId
1995 
    """
1996 
    self.send_batchOrders(warehouseId)
1997 
    return self.recv_batchOrders()
1998 
 
1999 
  def send_batchOrders(self, warehouseId):
2000 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2001 
    args = batchOrders_args()
2002 
    args.warehouseId = warehouseId
2003 
    args.write(self._oprot)
2004 
    self._oprot.writeMessageEnd()
2005 
    self._oprot.trans.flush()
2006 
 
2007 
  def recv_batchOrders(self, ):
2008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2009 
    if mtype == TMessageType.EXCEPTION:
2010 
      x = TApplicationException()
2011 
      x.read(self._iprot)
2012 
      self._iprot.readMessageEnd()
2013 
      raise x
2014 
    result = batchOrders_result()
2015 
    result.read(self._iprot)
2016 
    self._iprot.readMessageEnd()
3431 rajveer 2017 
    if result.success is not None:
1220 chandransh 2018 
      return result.success
3431 rajveer 2019 
    if result.ex is not None:
1220 chandransh 2020 
      raise result.ex
2021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2022 
 
1208 chandransh 2023 
  def markOrderAsOutOfStock(self, orderId):
2024 
    """
2025 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2026 
 
1208 chandransh 2027 
    Parameters:
2028 
     - orderId
2029 
    """
2030 
    self.send_markOrderAsOutOfStock(orderId)
2031 
    return self.recv_markOrderAsOutOfStock()
2032 
 
2033 
  def send_markOrderAsOutOfStock(self, orderId):
2034 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2035 
    args = markOrderAsOutOfStock_args()
2036 
    args.orderId = orderId
2037 
    args.write(self._oprot)
2038 
    self._oprot.writeMessageEnd()
2039 
    self._oprot.trans.flush()
2040 
 
2041 
  def recv_markOrderAsOutOfStock(self, ):
2042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2043 
    if mtype == TMessageType.EXCEPTION:
2044 
      x = TApplicationException()
2045 
      x.read(self._iprot)
2046 
      self._iprot.readMessageEnd()
2047 
      raise x
2048 
    result = markOrderAsOutOfStock_result()
2049 
    result.read(self._iprot)
2050 
    self._iprot.readMessageEnd()
3431 rajveer 2051 
    if result.success is not None:
1208 chandransh 2052 
      return result.success
3431 rajveer 2053 
    if result.ex is not None:
1208 chandransh 2054 
      raise result.ex
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2056 
 
3064 chandransh 2057 
  def verifyOrder(self, orderId):
759 chandransh 2058 
    """
3064 chandransh 2059 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2060 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2061 
    used for all other orders as well.
2062 
    Throws an exception if no such order exists.
3431 rajveer 2063 
 
759 chandransh 2064 
    Parameters:
3064 chandransh 2065 
     - orderId
759 chandransh 2066 
    """
3064 chandransh 2067 
    self.send_verifyOrder(orderId)
2068 
    return self.recv_verifyOrder()
759 chandransh 2069 
 
3064 chandransh 2070 
  def send_verifyOrder(self, orderId):
2071 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2072 
    args = verifyOrder_args()
2073 
    args.orderId = orderId
759 chandransh 2074 
    args.write(self._oprot)
2075 
    self._oprot.writeMessageEnd()
2076 
    self._oprot.trans.flush()
2077 
 
3064 chandransh 2078 
  def recv_verifyOrder(self, ):
759 chandransh 2079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2080 
    if mtype == TMessageType.EXCEPTION:
2081 
      x = TApplicationException()
2082 
      x.read(self._iprot)
2083 
      self._iprot.readMessageEnd()
2084 
      raise x
3064 chandransh 2085 
    result = verifyOrder_result()
759 chandransh 2086 
    result.read(self._iprot)
2087 
    self._iprot.readMessageEnd()
3431 rajveer 2088 
    if result.success is not None:
759 chandransh 2089 
      return result.success
3431 rajveer 2090 
    if result.ex is not None:
759 chandransh 2091 
      raise result.ex
3064 chandransh 2092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2093 
 
3064 chandransh 2094 
  def acceptOrder(self, orderId):
1113 chandransh 2095 
    """
3064 chandransh 2096 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2097 
    given order is not a COD order, it also captures the payment if the same has
2098 
    not been captured.
2099 
    Throws an exception if no such order exists.
3431 rajveer 2100 
 
1113 chandransh 2101 
    Parameters:
3064 chandransh 2102 
     - orderId
1113 chandransh 2103 
    """
3064 chandransh 2104 
    self.send_acceptOrder(orderId)
2105 
    return self.recv_acceptOrder()
1113 chandransh 2106 
 
3064 chandransh 2107 
  def send_acceptOrder(self, orderId):
2108 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2109 
    args = acceptOrder_args()
2110 
    args.orderId = orderId
1113 chandransh 2111 
    args.write(self._oprot)
2112 
    self._oprot.writeMessageEnd()
2113 
    self._oprot.trans.flush()
2114 
 
3064 chandransh 2115 
  def recv_acceptOrder(self, ):
1113 chandransh 2116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2117 
    if mtype == TMessageType.EXCEPTION:
2118 
      x = TApplicationException()
2119 
      x.read(self._iprot)
2120 
      self._iprot.readMessageEnd()
2121 
      raise x
3064 chandransh 2122 
    result = acceptOrder_result()
1113 chandransh 2123 
    result.read(self._iprot)
2124 
    self._iprot.readMessageEnd()
3431 rajveer 2125 
    if result.success is not None:
1113 chandransh 2126 
      return result.success
3431 rajveer 2127 
    if result.ex is not None:
1113 chandransh 2128 
      raise result.ex
3064 chandransh 2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2130 
 
4763 rajveer 2131 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2132 
    """
3064 chandransh 2133 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2134 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2135 
    the IMEI no. if a -1 is supplied.
2136 
    Also, it generates an invoice number for the order, marks the order as
2137 
    BILLED and sets the billing timestamp.
2138 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2139 
 
1135 chandransh 2140 
    Parameters:
3064 chandransh 2141 
     - orderId
2142 
     - invoice_number
4658 mandeep.dh 2143 
     - serialNumber
4283 anupam.sin 2144 
     - itemNumber
3064 chandransh 2145 
     - billed_by
4264 rajveer 2146 
     - jacketNumber
4283 anupam.sin 2147 
     - billingType
2148 
     - vendorId
4763 rajveer 2149 
     - authorize
1135 chandransh 2150 
    """
4763 rajveer 2151 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2152 
    return self.recv_addBillingDetails()
1135 chandransh 2153 
 
4763 rajveer 2154 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2155 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2156 
    args = addBillingDetails_args()
2157 
    args.orderId = orderId
2158 
    args.invoice_number = invoice_number
4658 mandeep.dh 2159 
    args.serialNumber = serialNumber
4283 anupam.sin 2160 
    args.itemNumber = itemNumber
3064 chandransh 2161 
    args.billed_by = billed_by
4264 rajveer 2162 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2163 
    args.billingType = billingType
2164 
    args.vendorId = vendorId
4763 rajveer 2165 
    args.authorize = authorize
1135 chandransh 2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
3064 chandransh 2170 
  def recv_addBillingDetails(self, ):
1135 chandransh 2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
3064 chandransh 2177 
    result = addBillingDetails_result()
1135 chandransh 2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
3064 chandransh 2181 
      return result.success
3431 rajveer 2182 
    if result.ex is not None:
1135 chandransh 2183 
      raise result.ex
3064 chandransh 2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2185 
 
4763 rajveer 2186 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2187 
    """
2188 
    Add the invoice number to the order.
2189 
 
2190 
    Parameters:
2191 
     - orderId
2192 
     - invoiceNumber
4763 rajveer 2193 
     - color
4579 rajveer 2194 
    """
4763 rajveer 2195 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2196 
    self.recv_addInvoiceNumber()
2197 
 
4763 rajveer 2198 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2199 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2200 
    args = addInvoiceNumber_args()
2201 
    args.orderId = orderId
2202 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2203 
    args.color = color
4579 rajveer 2204 
    args.write(self._oprot)
2205 
    self._oprot.writeMessageEnd()
2206 
    self._oprot.trans.flush()
2207 
 
2208 
  def recv_addInvoiceNumber(self, ):
2209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2210 
    if mtype == TMessageType.EXCEPTION:
2211 
      x = TApplicationException()
2212 
      x.read(self._iprot)
2213 
      self._iprot.readMessageEnd()
2214 
      raise x
2215 
    result = addInvoiceNumber_result()
2216 
    result.read(self._iprot)
2217 
    self._iprot.readMessageEnd()
2218 
    if result.ex is not None:
2219 
      raise result.ex
2220 
    return
2221 
 
3064 chandransh 2222 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2223 
    """
3064 chandransh 2224 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2225 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2226 
 
1408 ankur.sing 2227 
    Parameters:
3064 chandransh 2228 
     - warehouseId
1408 ankur.sing 2229 
     - providerId
3064 chandransh 2230 
     - cod
1408 ankur.sing 2231 
    """
3064 chandransh 2232 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2233 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2234 
 
3064 chandransh 2235 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2236 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2237 
    args = markOrdersAsManifested_args()
2238 
    args.warehouseId = warehouseId
1408 ankur.sing 2239 
    args.providerId = providerId
3064 chandransh 2240 
    args.cod = cod
1408 ankur.sing 2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
3064 chandransh 2245 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
3064 chandransh 2252 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.success is not None:
1408 ankur.sing 2256 
      return result.success
3431 rajveer 2257 
    if result.ex is not None:
3064 chandransh 2258 
      raise result.ex
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2260 
 
4410 rajveer 2261 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2262 
    """
2263 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2264 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2265 
 
2266 
    Parameters:
2267 
     - warehouseId
2268 
     - providerId
2269 
     - cod
2270 
    """
2271 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2272 
    return self.recv_markOrdersAsShippedFromWarehouse()
2273 
 
2274 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2275 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2276 
    args = markOrdersAsShippedFromWarehouse_args()
2277 
    args.warehouseId = warehouseId
2278 
    args.providerId = providerId
2279 
    args.cod = cod
2280 
    args.write(self._oprot)
2281 
    self._oprot.writeMessageEnd()
2282 
    self._oprot.trans.flush()
2283 
 
2284 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2286 
    if mtype == TMessageType.EXCEPTION:
2287 
      x = TApplicationException()
2288 
      x.read(self._iprot)
2289 
      self._iprot.readMessageEnd()
2290 
      raise x
2291 
    result = markOrdersAsShippedFromWarehouse_result()
2292 
    result.read(self._iprot)
2293 
    self._iprot.readMessageEnd()
2294 
    if result.success is not None:
2295 
      return result.success
2296 
    if result.ex is not None:
2297 
      raise result.ex
2298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2299 
 
3064 chandransh 2300 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2301 
    """
3064 chandransh 2302 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2303 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2304 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2305 
 
94 ashish 2306 
    Parameters:
3064 chandransh 2307 
     - providerId
2308 
     - pickupDetails
304 ashish 2309 
    """
3064 chandransh 2310 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2311 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2312 
 
3064 chandransh 2313 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2314 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2315 
    args = markOrdersAsPickedUp_args()
2316 
    args.providerId = providerId
2317 
    args.pickupDetails = pickupDetails
304 ashish 2318 
    args.write(self._oprot)
2319 
    self._oprot.writeMessageEnd()
2320 
    self._oprot.trans.flush()
2321 
 
3064 chandransh 2322 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2324 
    if mtype == TMessageType.EXCEPTION:
2325 
      x = TApplicationException()
2326 
      x.read(self._iprot)
2327 
      self._iprot.readMessageEnd()
2328 
      raise x
3064 chandransh 2329 
    result = markOrdersAsPickedUp_result()
304 ashish 2330 
    result.read(self._iprot)
2331 
    self._iprot.readMessageEnd()
3431 rajveer 2332 
    if result.success is not None:
304 ashish 2333 
      return result.success
3431 rajveer 2334 
    if result.ex is not None:
3064 chandransh 2335 
      raise result.ex
2336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2337 
 
3064 chandransh 2338 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2339 
    """
3064 chandransh 2340 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2341 
    the name of the receiver.
2342 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2343 
 
304 ashish 2344 
    Parameters:
3064 chandransh 2345 
     - providerId
2346 
     - deliveredOrders
304 ashish 2347 
    """
3064 chandransh 2348 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2349 
    self.recv_markOrdersAsDelivered()
304 ashish 2350 
 
3064 chandransh 2351 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2352 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2353 
    args = markOrdersAsDelivered_args()
2354 
    args.providerId = providerId
2355 
    args.deliveredOrders = deliveredOrders
304 ashish 2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
3064 chandransh 2360 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
3064 chandransh 2367 
    result = markOrdersAsDelivered_result()
304 ashish 2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
3431 rajveer 2370 
    if result.ex is not None:
3064 chandransh 2371 
      raise result.ex
304 ashish 2372 
    return
2373 
 
3064 chandransh 2374 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2375 
    """
3064 chandransh 2376 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2378 
 
3064 chandransh 2379 
    Parameters:
2380 
     - providerId
2381 
     - returnedOrders
1596 ankur.sing 2382 
    """
3064 chandransh 2383 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2384 
    self.recv_markOrdersAsFailed()
304 ashish 2385 
 
3064 chandransh 2386 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2387 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2388 
    args = markOrdersAsFailed_args()
2389 
    args.providerId = providerId
2390 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2391 
    args.write(self._oprot)
2392 
    self._oprot.writeMessageEnd()
2393 
    self._oprot.trans.flush()
2394 
 
3064 chandransh 2395 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2397 
    if mtype == TMessageType.EXCEPTION:
2398 
      x = TApplicationException()
2399 
      x.read(self._iprot)
2400 
      self._iprot.readMessageEnd()
2401 
      raise x
3064 chandransh 2402 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2403 
    result.read(self._iprot)
2404 
    self._iprot.readMessageEnd()
3431 rajveer 2405 
    if result.ex is not None:
3064 chandransh 2406 
      raise result.ex
2407 
    return
1596 ankur.sing 2408 
 
3064 chandransh 2409 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2410 
    """
3064 chandransh 2411 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2412 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2413 
 
3064 chandransh 2414 
    Parameters:
2415 
     - providerId
2416 
     - undeliveredOrders
1627 ankur.sing 2417 
    """
3064 chandransh 2418 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2419 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2420 
 
3064 chandransh 2421 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2422 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2423 
    args = updateNonDeliveryReason_args()
2424 
    args.providerId = providerId
2425 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
3064 chandransh 2430 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
3064 chandransh 2437 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
4581 phani.kuma 2440 
    if result.success is not None:
2441 
      return result.success
3431 rajveer 2442 
    if result.ex is not None:
3064 chandransh 2443 
      raise result.ex
4581 phani.kuma 2444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2445 
 
3064 chandransh 2446 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2447 
    """
3064 chandransh 2448 
    Returns the list of orders whose delivery time has passed but have not been
2449 
    delivered yet for the given provider and warehouse. To get a complete list of
2450 
    undelivered orders, pass them as -1.
2451 
    Returns an empty list if no such orders exist.
3431 rajveer 2452 
 
1886 ankur.sing 2453 
    Parameters:
3064 chandransh 2454 
     - providerId
2455 
     - warehouseId
1886 ankur.sing 2456 
    """
3064 chandransh 2457 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2458 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2459 
 
3064 chandransh 2460 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2461 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2462 
    args = getUndeliveredOrders_args()
2463 
    args.providerId = providerId
2464 
    args.warehouseId = warehouseId
1886 ankur.sing 2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
3064 chandransh 2469 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
3064 chandransh 2476 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
3431 rajveer 2479 
    if result.success is not None:
1886 ankur.sing 2480 
      return result.success
3064 chandransh 2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2482 
 
2536 chandransh 2483 
  def toggleDOAFlag(self, orderId):
2484 
    """
2485 
    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.
2486 
    Returns the final flag status.
2487 
    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 2488 
 
2536 chandransh 2489 
    Parameters:
2490 
     - orderId
2491 
    """
2492 
    self.send_toggleDOAFlag(orderId)
2493 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2494 
 
2536 chandransh 2495 
  def send_toggleDOAFlag(self, orderId):
2496 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2497 
    args = toggleDOAFlag_args()
2498 
    args.orderId = orderId
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_toggleDOAFlag(self, ):
2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
2510 
    result = toggleDOAFlag_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
3431 rajveer 2513 
    if result.success is not None:
2536 chandransh 2514 
      return result.success
3431 rajveer 2515 
    if result.ex is not None:
2536 chandransh 2516 
      raise result.ex
2517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2518 
 
4712 rajveer 2519 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2520 
    """
2521 
    Parameters:
2522 
     - orderId
2523 
     - deliveryTimestamp
2524 
     - receiver
2525 
    """
2526 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2527 
    self.recv_markOrderAsDelivered()
2528 
 
2529 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2530 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2531 
    args = markOrderAsDelivered_args()
2532 
    args.orderId = orderId
2533 
    args.deliveryTimestamp = deliveryTimestamp
2534 
    args.receiver = receiver
2535 
    args.write(self._oprot)
2536 
    self._oprot.writeMessageEnd()
2537 
    self._oprot.trans.flush()
2538 
 
2539 
  def recv_markOrderAsDelivered(self, ):
2540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2541 
    if mtype == TMessageType.EXCEPTION:
2542 
      x = TApplicationException()
2543 
      x.read(self._iprot)
2544 
      self._iprot.readMessageEnd()
2545 
      raise x
2546 
    result = markOrderAsDelivered_result()
2547 
    result.read(self._iprot)
2548 
    self._iprot.readMessageEnd()
2549 
    if result.ex is not None:
2550 
      raise result.ex
2551 
    return
2552 
 
4454 rajveer 2553 
  def markOrderDoaRequestReceived(self, orderId):
2554 
    """
2555 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2556 
 
2557 
    Parameters:
2558 
     - orderId
2559 
    """
2560 
    self.send_markOrderDoaRequestReceived(orderId)
2561 
    return self.recv_markOrderDoaRequestReceived()
2562 
 
2563 
  def send_markOrderDoaRequestReceived(self, orderId):
2564 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2565 
    args = markOrderDoaRequestReceived_args()
2566 
    args.orderId = orderId
2567 
    args.write(self._oprot)
2568 
    self._oprot.writeMessageEnd()
2569 
    self._oprot.trans.flush()
2570 
 
2571 
  def recv_markOrderDoaRequestReceived(self, ):
2572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2573 
    if mtype == TMessageType.EXCEPTION:
2574 
      x = TApplicationException()
2575 
      x.read(self._iprot)
2576 
      self._iprot.readMessageEnd()
2577 
      raise x
2578 
    result = markOrderDoaRequestReceived_result()
2579 
    result.read(self._iprot)
2580 
    self._iprot.readMessageEnd()
2581 
    if result.success is not None:
2582 
      return result.success
2583 
    if result.ex is not None:
2584 
      raise result.ex
2585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2586 
 
2587 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2588 
    """
2589 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2590 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2591 
 
2592 
    Parameters:
2593 
     - orderId
2594 
     - isAuthorized
2595 
    """
2596 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2597 
    return self.recv_markOrderDoaRequestAuthorized()
2598 
 
2599 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2600 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2601 
    args = markOrderDoaRequestAuthorized_args()
2602 
    args.orderId = orderId
2603 
    args.isAuthorized = isAuthorized
2604 
    args.write(self._oprot)
2605 
    self._oprot.writeMessageEnd()
2606 
    self._oprot.trans.flush()
2607 
 
2608 
  def recv_markOrderDoaRequestAuthorized(self, ):
2609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2610 
    if mtype == TMessageType.EXCEPTION:
2611 
      x = TApplicationException()
2612 
      x.read(self._iprot)
2613 
      self._iprot.readMessageEnd()
2614 
      raise x
2615 
    result = markOrderDoaRequestAuthorized_result()
2616 
    result.read(self._iprot)
2617 
    self._iprot.readMessageEnd()
2618 
    if result.success is not None:
2619 
      return result.success
2620 
    if result.ex is not None:
2621 
      raise result.ex
2622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2623 
 
4488 rajveer 2624 
  def markOrderReturnRequestReceived(self, orderId):
2625 
    """
2626 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2627 
 
2628 
    Parameters:
2629 
     - orderId
2630 
    """
2631 
    self.send_markOrderReturnRequestReceived(orderId)
2632 
    return self.recv_markOrderReturnRequestReceived()
2633 
 
2634 
  def send_markOrderReturnRequestReceived(self, orderId):
2635 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2636 
    args = markOrderReturnRequestReceived_args()
2637 
    args.orderId = orderId
2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
2642 
  def recv_markOrderReturnRequestReceived(self, ):
2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
2649 
    result = markOrderReturnRequestReceived_result()
2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
2652 
    if result.success is not None:
2653 
      return result.success
2654 
    if result.ex is not None:
2655 
      raise result.ex
2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2657 
 
2658 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2659 
    """
2660 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2661 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2662 
 
2663 
    Parameters:
2664 
     - orderId
2665 
     - isAuthorized
2666 
    """
2667 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2668 
    return self.recv_markOrderReturnRequestAuthorized()
2669 
 
2670 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2671 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2672 
    args = markOrderReturnRequestAuthorized_args()
2673 
    args.orderId = orderId
2674 
    args.isAuthorized = isAuthorized
2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_markOrderReturnRequestAuthorized(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = markOrderReturnRequestAuthorized_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
2689 
    if result.success is not None:
2690 
      return result.success
2691 
    if result.ex is not None:
2692 
      raise result.ex
2693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2694 
 
4579 rajveer 2695 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2696 
    """
2697 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2698 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2699 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2700 
    For any other status, it returns false.
2701 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2702 
 
2536 chandransh 2703 
    Parameters:
2704 
     - orderId
4579 rajveer 2705 
     - providerId
2536 chandransh 2706 
    """
4579 rajveer 2707 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2708 
    return self.recv_requestPickupNumber()
2709 
 
4579 rajveer 2710 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2711 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2712 
    args = requestPickupNumber_args()
2713 
    args.orderId = orderId
4579 rajveer 2714 
    args.providerId = providerId
2536 chandransh 2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_requestPickupNumber(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = requestPickupNumber_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
3431 rajveer 2729 
    if result.success is not None:
2536 chandransh 2730 
      return result.success
3431 rajveer 2731 
    if result.ex is not None:
2536 chandransh 2732 
      raise result.ex
2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2734 
 
4602 rajveer 2735 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2736 
    """
4452 rajveer 2737 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2738 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2739 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2740 
    	3. Returns true
2591 chandransh 2741 
    If the order is in any other status, it returns false.
2536 chandransh 2742 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2743 
 
2536 chandransh 2744 
    Parameters:
2745 
     - orderId
2746 
     - pickupNumber
4602 rajveer 2747 
     - providerId
2536 chandransh 2748 
    """
4602 rajveer 2749 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2750 
    return self.recv_authorizePickup()
2751 
 
4602 rajveer 2752 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2753 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2754 
    args = authorizePickup_args()
2755 
    args.orderId = orderId
2756 
    args.pickupNumber = pickupNumber
4602 rajveer 2757 
    args.providerId = providerId
2536 chandransh 2758 
    args.write(self._oprot)
2759 
    self._oprot.writeMessageEnd()
2760 
    self._oprot.trans.flush()
2761 
 
2762 
  def recv_authorizePickup(self, ):
2763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2764 
    if mtype == TMessageType.EXCEPTION:
2765 
      x = TApplicationException()
2766 
      x.read(self._iprot)
2767 
      self._iprot.readMessageEnd()
2768 
      raise x
2769 
    result = authorizePickup_result()
2770 
    result.read(self._iprot)
2771 
    self._iprot.readMessageEnd()
3431 rajveer 2772 
    if result.success is not None:
2536 chandransh 2773 
      return result.success
3431 rajveer 2774 
    if result.ex is not None:
2536 chandransh 2775 
      raise result.ex
2776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2777 
 
2764 chandransh 2778 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2779 
    """
2780 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2781 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2782 
 
2764 chandransh 2783 
    Parameters:
2784 
     - providerId
2785 
     - pickupDetails
2786 
    """
2787 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2788 
    return self.recv_markDoasAsPickedUp()
2789 
 
2790 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2791 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2792 
    args = markDoasAsPickedUp_args()
2793 
    args.providerId = providerId
2794 
    args.pickupDetails = pickupDetails
2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
2799 
  def recv_markDoasAsPickedUp(self, ):
2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
2806 
    result = markDoasAsPickedUp_result()
2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
3431 rajveer 2809 
    if result.success is not None:
2764 chandransh 2810 
      return result.success
2811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2812 
 
4741 phani.kuma 2813 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2814 
    """
2815 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2816 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2817 
 
2818 
    Parameters:
2819 
     - providerId
2820 
     - pickupDetails
2821 
    """
2822 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2823 
    return self.recv_markReturnOrdersAsPickedUp()
2824 
 
2825 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2826 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2827 
    args = markReturnOrdersAsPickedUp_args()
2828 
    args.providerId = providerId
2829 
    args.pickupDetails = pickupDetails
2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2834 
  def recv_markReturnOrdersAsPickedUp(self, ):
2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2841 
    result = markReturnOrdersAsPickedUp_result()
2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    if result.success is not None:
2845 
      return result.success
2846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2847 
 
4479 rajveer 2848 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2849 
    """
4452 rajveer 2850 
    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 2851 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2852 
    If the order is in any other state, it returns false.
2853 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2854 
 
2591 chandransh 2855 
    Parameters:
2856 
     - orderId
4479 rajveer 2857 
     - receiveCondition
2591 chandransh 2858 
    """
4479 rajveer 2859 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2860 
    return self.recv_receiveReturn()
2536 chandransh 2861 
 
4479 rajveer 2862 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2863 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2864 
    args = receiveReturn_args()
2591 chandransh 2865 
    args.orderId = orderId
4479 rajveer 2866 
    args.receiveCondition = receiveCondition
2591 chandransh 2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
2616 chandransh 2871 
  def recv_receiveReturn(self, ):
2591 chandransh 2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
2616 chandransh 2878 
    result = receiveReturn_result()
2591 chandransh 2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
3431 rajveer 2881 
    if result.success is not None:
2591 chandransh 2882 
      return result.success
3431 rajveer 2883 
    if result.ex is not None:
2591 chandransh 2884 
      raise result.ex
2616 chandransh 2885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2886 
 
2887 
  def validateDoa(self, orderId, isValid):
2888 
    """
4452 rajveer 2889 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2890 
    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 2891 
    If the order is in any other state, it returns false.
2892 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2893 
 
2591 chandransh 2894 
    Parameters:
2895 
     - orderId
2896 
     - isValid
2897 
    """
2898 
    self.send_validateDoa(orderId, isValid)
2899 
    return self.recv_validateDoa()
2900 
 
2901 
  def send_validateDoa(self, orderId, isValid):
2902 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2903 
    args = validateDoa_args()
2904 
    args.orderId = orderId
2905 
    args.isValid = isValid
2906 
    args.write(self._oprot)
2907 
    self._oprot.writeMessageEnd()
2908 
    self._oprot.trans.flush()
2909 
 
2910 
  def recv_validateDoa(self, ):
2911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2912 
    if mtype == TMessageType.EXCEPTION:
2913 
      x = TApplicationException()
2914 
      x.read(self._iprot)
2915 
      self._iprot.readMessageEnd()
2916 
      raise x
2917 
    result = validateDoa_result()
2918 
    result.read(self._iprot)
2919 
    self._iprot.readMessageEnd()
3431 rajveer 2920 
    if result.success is not None:
2591 chandransh 2921 
      return result.success
3431 rajveer 2922 
    if result.ex is not None:
2591 chandransh 2923 
      raise result.ex
2924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2925 
 
4495 rajveer 2926 
  def validateReturnProduct(self, orderId, isUsable):
2927 
    """
2928 
    Parameters:
2929 
     - orderId
2930 
     - isUsable
2931 
    """
2932 
    self.send_validateReturnProduct(orderId, isUsable)
2933 
    return self.recv_validateReturnProduct()
2934 
 
2935 
  def send_validateReturnProduct(self, orderId, isUsable):
2936 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2937 
    args = validateReturnProduct_args()
2938 
    args.orderId = orderId
2939 
    args.isUsable = isUsable
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_validateReturnProduct(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = validateReturnProduct_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    if result.ex is not None:
2957 
      raise result.ex
2958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2959 
 
2616 chandransh 2960 
  def reshipOrder(self, orderId):
2961 
    """
4484 rajveer 2962 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2963 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2964 
    	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 2965 
 
2966 
    If the order is in DOA_CERT_VALID state, it does the following:
2967 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2968 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2969 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2970 
 
2616 chandransh 2971 
    Returns the id of the newly created order.
3431 rajveer 2972 
 
2616 chandransh 2973 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2974 
 
2616 chandransh 2975 
    Parameters:
2976 
     - orderId
2977 
    """
2978 
    self.send_reshipOrder(orderId)
2979 
    return self.recv_reshipOrder()
2591 chandransh 2980 
 
2616 chandransh 2981 
  def send_reshipOrder(self, orderId):
2982 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2983 
    args = reshipOrder_args()
2984 
    args.orderId = orderId
2985 
    args.write(self._oprot)
2986 
    self._oprot.writeMessageEnd()
2987 
    self._oprot.trans.flush()
2988 
 
2989 
  def recv_reshipOrder(self, ):
2990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2991 
    if mtype == TMessageType.EXCEPTION:
2992 
      x = TApplicationException()
2993 
      x.read(self._iprot)
2994 
      self._iprot.readMessageEnd()
2995 
      raise x
2996 
    result = reshipOrder_result()
2997 
    result.read(self._iprot)
2998 
    self._iprot.readMessageEnd()
3431 rajveer 2999 
    if result.success is not None:
2616 chandransh 3000 
      return result.success
3431 rajveer 3001 
    if result.ex is not None:
2616 chandransh 3002 
      raise result.ex
3003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3004 
 
3226 chandransh 3005 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3006 
    """
4484 rajveer 3007 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3008 
    	1. Creates a refund request for batch processing.
3009 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3010 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3011 
 
2616 chandransh 3012 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3013 
    	1. Creates a refund request for batch processing.
3226 chandransh 3014 
    	2. Cancels the reservation of the item in the warehouse.
3015 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3016 
 
3226 chandransh 3017 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3018 
    	1. Cancels the reservation of the item in the warehouse.
3019 
    	2. Marks the current order as CANCELED.
3020 
 
3021 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3022 
 
2616 chandransh 3023 
    Returns True if it is successful, False otherwise.
3431 rajveer 3024 
 
2616 chandransh 3025 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3026 
 
2616 chandransh 3027 
    Parameters:
3028 
     - orderId
3226 chandransh 3029 
     - refundedBy
3030 
     - reason
2616 chandransh 3031 
    """
3226 chandransh 3032 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3033 
    return self.recv_refundOrder()
3034 
 
3226 chandransh 3035 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3036 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3037 
    args = refundOrder_args()
3038 
    args.orderId = orderId
3226 chandransh 3039 
    args.refundedBy = refundedBy
3040 
    args.reason = reason
2616 chandransh 3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_refundOrder(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = refundOrder_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3431 rajveer 3055 
    if result.success is not None:
2616 chandransh 3056 
      return result.success
3431 rajveer 3057 
    if result.ex is not None:
2616 chandransh 3058 
      raise result.ex
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3060 
 
2690 chandransh 3061 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3062 
    """
3063 
    Get all return orders created between the from and to dates for the given warehouse.
3064 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3065 
 
2690 chandransh 3066 
    Parameters:
3067 
     - warehouseId
3068 
     - fromDate
3069 
     - toDate
3070 
    """
3071 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3072 
    return self.recv_getReturnOrders()
2616 chandransh 3073 
 
2690 chandransh 3074 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3075 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3076 
    args = getReturnOrders_args()
3077 
    args.warehouseId = warehouseId
3078 
    args.fromDate = fromDate
3079 
    args.toDate = toDate
3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
3084 
  def recv_getReturnOrders(self, ):
3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
3091 
    result = getReturnOrders_result()
3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3431 rajveer 3094 
    if result.success is not None:
2690 chandransh 3095 
      return result.success
3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3097 
 
2700 chandransh 3098 
  def getReturnOrder(self, id):
3099 
    """
3100 
    Returns the ReturnOrder corresponding to the given id.
3101 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3102 
 
2700 chandransh 3103 
    Parameters:
3104 
     - id
3105 
    """
3106 
    self.send_getReturnOrder(id)
3107 
    return self.recv_getReturnOrder()
3108 
 
3109 
  def send_getReturnOrder(self, id):
3110 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3111 
    args = getReturnOrder_args()
3112 
    args.id = id
3113 
    args.write(self._oprot)
3114 
    self._oprot.writeMessageEnd()
3115 
    self._oprot.trans.flush()
3116 
 
3117 
  def recv_getReturnOrder(self, ):
3118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3119 
    if mtype == TMessageType.EXCEPTION:
3120 
      x = TApplicationException()
3121 
      x.read(self._iprot)
3122 
      self._iprot.readMessageEnd()
3123 
      raise x
3124 
    result = getReturnOrder_result()
3125 
    result.read(self._iprot)
3126 
    self._iprot.readMessageEnd()
3431 rajveer 3127 
    if result.success is not None:
2700 chandransh 3128 
      return result.success
3431 rajveer 3129 
    if result.ex is not None:
2700 chandransh 3130 
      raise result.ex
3131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3132 
 
2690 chandransh 3133 
  def processReturn(self, returnOrderId):
3134 
    """
3135 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3136 
 
2690 chandransh 3137 
    Parameters:
3138 
     - returnOrderId
3139 
    """
3140 
    self.send_processReturn(returnOrderId)
3141 
    self.recv_processReturn()
3142 
 
3143 
  def send_processReturn(self, returnOrderId):
3144 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3145 
    args = processReturn_args()
3146 
    args.returnOrderId = returnOrderId
3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
3151 
  def recv_processReturn(self, ):
3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
3158 
    result = processReturn_result()
3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3431 rajveer 3161 
    if result.ex is not None:
2690 chandransh 3162 
      raise result.ex
3163 
    return
3164 
 
3451 chandransh 3165 
  def updateWeight(self, orderId, weight):
3166 
    """
3167 
    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 3168 
 
3451 chandransh 3169 
    Parameters:
3170 
     - orderId
3171 
     - weight
3172 
    """
3173 
    self.send_updateWeight(orderId, weight)
3174 
    return self.recv_updateWeight()
3175 
 
3176 
  def send_updateWeight(self, orderId, weight):
3177 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3178 
    args = updateWeight_args()
3179 
    args.orderId = orderId
3180 
    args.weight = weight
3181 
    args.write(self._oprot)
3182 
    self._oprot.writeMessageEnd()
3183 
    self._oprot.trans.flush()
3184 
 
3185 
  def recv_updateWeight(self, ):
3186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3187 
    if mtype == TMessageType.EXCEPTION:
3188 
      x = TApplicationException()
3189 
      x.read(self._iprot)
3190 
      self._iprot.readMessageEnd()
3191 
      raise x
3192 
    result = updateWeight_result()
3193 
    result.read(self._iprot)
3194 
    self._iprot.readMessageEnd()
3195 
    if result.success is not None:
3196 
      return result.success
3197 
    if result.ex is not None:
3198 
      raise result.ex
3199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3200 
 
3469 chandransh 3201 
  def changeItem(self, orderId, itemId):
3202 
    """
3203 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3204 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3205 
 
3469 chandransh 3206 
    Parameters:
3207 
     - orderId
3208 
     - itemId
3209 
    """
3210 
    self.send_changeItem(orderId, itemId)
3211 
    return self.recv_changeItem()
3212 
 
3213 
  def send_changeItem(self, orderId, itemId):
3214 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3215 
    args = changeItem_args()
3216 
    args.orderId = orderId
3217 
    args.itemId = itemId
3218 
    args.write(self._oprot)
3219 
    self._oprot.writeMessageEnd()
3220 
    self._oprot.trans.flush()
3221 
 
3222 
  def recv_changeItem(self, ):
3223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3224 
    if mtype == TMessageType.EXCEPTION:
3225 
      x = TApplicationException()
3226 
      x.read(self._iprot)
3227 
      self._iprot.readMessageEnd()
3228 
      raise x
3229 
    result = changeItem_result()
3230 
    result.read(self._iprot)
3231 
    self._iprot.readMessageEnd()
3232 
    if result.success is not None:
3233 
      return result.success
3234 
    if result.ex is not None:
3235 
      raise result.ex
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3237 
 
3238 
  def shiftToWarehouse(self, orderId, warehouseId):
3239 
    """
3240 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3241 
 
3242 
    Parameters:
3243 
     - orderId
3244 
     - warehouseId
3245 
    """
3246 
    self.send_shiftToWarehouse(orderId, warehouseId)
3247 
    return self.recv_shiftToWarehouse()
3248 
 
3249 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3250 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3251 
    args = shiftToWarehouse_args()
3252 
    args.orderId = orderId
3253 
    args.warehouseId = warehouseId
3254 
    args.write(self._oprot)
3255 
    self._oprot.writeMessageEnd()
3256 
    self._oprot.trans.flush()
3257 
 
3258 
  def recv_shiftToWarehouse(self, ):
3259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3260 
    if mtype == TMessageType.EXCEPTION:
3261 
      x = TApplicationException()
3262 
      x.read(self._iprot)
3263 
      self._iprot.readMessageEnd()
3264 
      raise x
3265 
    result = shiftToWarehouse_result()
3266 
    result.read(self._iprot)
3267 
    self._iprot.readMessageEnd()
3268 
    if result.success is not None:
3269 
      return result.success
3270 
    if result.ex is not None:
3271 
      raise result.ex
3272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3273 
 
4647 rajveer 3274 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3275 
    """
3276 
    Adds the given delay reason to the given order.
3986 chandransh 3277 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3278 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3279 
 
3553 chandransh 3280 
    Parameters:
3281 
     - orderId
3282 
     - delayReason
3986 chandransh 3283 
     - furtherDelay
4647 rajveer 3284 
     - delayReasonText
3553 chandransh 3285 
    """
4647 rajveer 3286 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3287 
    return self.recv_addDelayReason()
3288 
 
4647 rajveer 3289 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3290 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3291 
    args = addDelayReason_args()
3292 
    args.orderId = orderId
3293 
    args.delayReason = delayReason
3986 chandransh 3294 
    args.furtherDelay = furtherDelay
4647 rajveer 3295 
    args.delayReasonText = delayReasonText
3553 chandransh 3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3300 
  def recv_addDelayReason(self, ):
3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3307 
    result = addDelayReason_result()
3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3310 
    if result.success is not None:
3311 
      return result.success
3312 
    if result.ex is not None:
3313 
      raise result.ex
3314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3315 
 
3956 chandransh 3316 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3317 
    """
3318 
    Marks the COD orders with given AWB nos. as having been processed.
3319 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3320 
 
3956 chandransh 3321 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3322 
    1. There is no order corresponding to an AWB number.
3323 
    2. The captured amount for a payment exceeds the total payment.
3324 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3325 
 
3326 
    Parameters:
3327 
     - collectedAmountMap
3328 
     - xferBy
3329 
     - xferTxnId
3330 
     - xferDate
3331 
    """
3332 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3333 
    return self.recv_reconcileCodCollection()
3334 
 
3335 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3336 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3337 
    args = reconcileCodCollection_args()
3338 
    args.collectedAmountMap = collectedAmountMap
3339 
    args.xferBy = xferBy
3340 
    args.xferTxnId = xferTxnId
3341 
    args.xferDate = xferDate
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_reconcileCodCollection(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = reconcileCodCollection_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.success is not None:
3357 
      return result.success
3358 
    if result.ex is not None:
3359 
      raise result.ex
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3361 
 
4008 mandeep.dh 3362 
  def getTransactionsRequiringExtraProcessing(self, category):
3363 
    """
4065 mandeep.dh 3364 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3365 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3366 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3367 
 
4008 mandeep.dh 3368 
    Parameters:
3369 
     - category
3370 
    """
3371 
    self.send_getTransactionsRequiringExtraProcessing(category)
3372 
    return self.recv_getTransactionsRequiringExtraProcessing()
3373 
 
3374 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3375 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3376 
    args = getTransactionsRequiringExtraProcessing_args()
3377 
    args.category = category
3378 
    args.write(self._oprot)
3379 
    self._oprot.writeMessageEnd()
3380 
    self._oprot.trans.flush()
3381 
 
3382 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3384 
    if mtype == TMessageType.EXCEPTION:
3385 
      x = TApplicationException()
3386 
      x.read(self._iprot)
3387 
      self._iprot.readMessageEnd()
3388 
      raise x
3389 
    result = getTransactionsRequiringExtraProcessing_result()
3390 
    result.read(self._iprot)
3391 
    self._iprot.readMessageEnd()
3392 
    if result.success is not None:
3393 
      return result.success
3394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3395 
 
3396 
  def markTransactionAsProcessed(self, transactionId, category):
3397 
    """
3398 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3399 
    It essentially deletes the transaction id record for a particular
3400 
    processing type category (if present) from DB.
3401 
    This is currently used by CRM application.
4008 mandeep.dh 3402 
 
3403 
    Parameters:
3404 
     - transactionId
3405 
     - category
3406 
    """
3407 
    self.send_markTransactionAsProcessed(transactionId, category)
3408 
    self.recv_markTransactionAsProcessed()
3409 
 
3410 
  def send_markTransactionAsProcessed(self, transactionId, category):
3411 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3412 
    args = markTransactionAsProcessed_args()
3413 
    args.transactionId = transactionId
3414 
    args.category = category
3415 
    args.write(self._oprot)
3416 
    self._oprot.writeMessageEnd()
3417 
    self._oprot.trans.flush()
3418 
 
3419 
  def recv_markTransactionAsProcessed(self, ):
3420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3421 
    if mtype == TMessageType.EXCEPTION:
3422 
      x = TApplicationException()
3423 
      x.read(self._iprot)
3424 
      self._iprot.readMessageEnd()
3425 
      raise x
3426 
    result = markTransactionAsProcessed_result()
3427 
    result.read(self._iprot)
3428 
    self._iprot.readMessageEnd()
3429 
    return
3430 
 
4018 chandransh 3431 
  def getItemWiseRiskyOrdersCount(self, ):
3432 
    """
3433 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3434 
    is defined as one whose shipping date is about to expire.
3435 
    """
3436 
    self.send_getItemWiseRiskyOrdersCount()
3437 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3438 
 
4018 chandransh 3439 
  def send_getItemWiseRiskyOrdersCount(self, ):
3440 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3441 
    args = getItemWiseRiskyOrdersCount_args()
3442 
    args.write(self._oprot)
3443 
    self._oprot.writeMessageEnd()
3444 
    self._oprot.trans.flush()
3445 
 
3446 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3448 
    if mtype == TMessageType.EXCEPTION:
3449 
      x = TApplicationException()
3450 
      x.read(self._iprot)
3451 
      self._iprot.readMessageEnd()
3452 
      raise x
3453 
    result = getItemWiseRiskyOrdersCount_result()
3454 
    result.read(self._iprot)
3455 
    self._iprot.readMessageEnd()
3456 
    if result.success is not None:
3457 
      return result.success
3458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3459 
 
4295 varun.gupt 3460 
  def getOrdersForItemIds(self, itemIds):
3461 
    """
3462 
    Returns a list of all orders which have items with given id
3463 
 
3464 
    Parameters:
3465 
     - itemIds
3466 
    """
3467 
    self.send_getOrdersForItemIds(itemIds)
3468 
    return self.recv_getOrdersForItemIds()
3469 
 
3470 
  def send_getOrdersForItemIds(self, itemIds):
3471 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3472 
    args = getOrdersForItemIds_args()
3473 
    args.itemIds = itemIds
3474 
    args.write(self._oprot)
3475 
    self._oprot.writeMessageEnd()
3476 
    self._oprot.trans.flush()
3477 
 
3478 
  def recv_getOrdersForItemIds(self, ):
3479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3480 
    if mtype == TMessageType.EXCEPTION:
3481 
      x = TApplicationException()
3482 
      x.read(self._iprot)
3483 
      self._iprot.readMessageEnd()
3484 
      raise x
3485 
    result = getOrdersForItemIds_result()
3486 
    result.read(self._iprot)
3487 
    self._iprot.readMessageEnd()
3488 
    if result.success is not None:
3489 
      return result.success
3490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3491 
 
4247 rajveer 3492 
  def markOrderCancellationRequestReceived(self, orderId):
3493 
    """
3494 
    Mark order as cancellation request received. If customer sends request of cancellation of
3495 
    a particular order, this method will be called. It will just change status of the order
3496 
    depending on its current status. It also records the previous status, so that we can move
3497 
    back to that status if cancellation request is denied.
4018 chandransh 3498 
 
4247 rajveer 3499 
    Parameters:
3500 
     - orderId
3501 
    """
3502 
    self.send_markOrderCancellationRequestReceived(orderId)
3503 
    self.recv_markOrderCancellationRequestReceived()
3504 
 
3505 
  def send_markOrderCancellationRequestReceived(self, orderId):
3506 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3507 
    args = markOrderCancellationRequestReceived_args()
3508 
    args.orderId = orderId
3509 
    args.write(self._oprot)
3510 
    self._oprot.writeMessageEnd()
3511 
    self._oprot.trans.flush()
3512 
 
3513 
  def recv_markOrderCancellationRequestReceived(self, ):
3514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3515 
    if mtype == TMessageType.EXCEPTION:
3516 
      x = TApplicationException()
3517 
      x.read(self._iprot)
3518 
      self._iprot.readMessageEnd()
3519 
      raise x
3520 
    result = markOrderCancellationRequestReceived_result()
3521 
    result.read(self._iprot)
3522 
    self._iprot.readMessageEnd()
3523 
    if result.ex is not None:
3524 
      raise result.ex
3525 
    return
3526 
 
3527 
  def markOrderCancellationRequestConfirmed(self, orderId):
3528 
    """
3529 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3530 
    cancellation request confirmed. After this OM will be able to cancel the order.
3531 
 
3532 
    Parameters:
3533 
     - orderId
3534 
    """
3535 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3536 
    self.recv_markOrderCancellationRequestConfirmed()
3537 
 
3538 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3539 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3540 
    args = markOrderCancellationRequestConfirmed_args()
3541 
    args.orderId = orderId
3542 
    args.write(self._oprot)
3543 
    self._oprot.writeMessageEnd()
3544 
    self._oprot.trans.flush()
3545 
 
3546 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3548 
    if mtype == TMessageType.EXCEPTION:
3549 
      x = TApplicationException()
3550 
      x.read(self._iprot)
3551 
      self._iprot.readMessageEnd()
3552 
      raise x
3553 
    result = markOrderCancellationRequestConfirmed_result()
3554 
    result.read(self._iprot)
3555 
    self._iprot.readMessageEnd()
3556 
    if result.ex is not None:
3557 
      raise result.ex
3558 
    return
3559 
 
3560 
  def markOrderCancellationRequestDenied(self, orderId):
3561 
    """
3562 
    If we decide to not to cancel order, we will move the order ro previous status.
3563 
 
3564 
    Parameters:
3565 
     - orderId
3566 
    """
3567 
    self.send_markOrderCancellationRequestDenied(orderId)
3568 
    self.recv_markOrderCancellationRequestDenied()
3569 
 
3570 
  def send_markOrderCancellationRequestDenied(self, orderId):
3571 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3572 
    args = markOrderCancellationRequestDenied_args()
3573 
    args.orderId = orderId
3574 
    args.write(self._oprot)
3575 
    self._oprot.writeMessageEnd()
3576 
    self._oprot.trans.flush()
3577 
 
3578 
  def recv_markOrderCancellationRequestDenied(self, ):
3579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3580 
    if mtype == TMessageType.EXCEPTION:
3581 
      x = TApplicationException()
3582 
      x.read(self._iprot)
3583 
      self._iprot.readMessageEnd()
3584 
      raise x
3585 
    result = markOrderCancellationRequestDenied_result()
3586 
    result.read(self._iprot)
3587 
    self._iprot.readMessageEnd()
3588 
    if result.ex is not None:
3589 
      raise result.ex
3590 
    return
3591 
 
4258 rajveer 3592 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3593 
    """
4258 rajveer 3594 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3595 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3596 
 
3597 
    Parameters:
4258 rajveer 3598 
     - transactionId
4247 rajveer 3599 
    """
4258 rajveer 3600 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3601 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3602 
 
4258 rajveer 3603 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3604 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3605 
    args = markTransactionAsPaymentFlagRemoved_args()
3606 
    args.transactionId = transactionId
4247 rajveer 3607 
    args.write(self._oprot)
3608 
    self._oprot.writeMessageEnd()
3609 
    self._oprot.trans.flush()
3610 
 
4258 rajveer 3611 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3613 
    if mtype == TMessageType.EXCEPTION:
3614 
      x = TApplicationException()
3615 
      x.read(self._iprot)
3616 
      self._iprot.readMessageEnd()
3617 
      raise x
4258 rajveer 3618 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3619 
    result.read(self._iprot)
3620 
    self._iprot.readMessageEnd()
3621 
    if result.ex is not None:
3622 
      raise result.ex
3623 
    return
3624 
 
4259 anupam.sin 3625 
  def refundTransaction(self, transactionId, refundedBy, reason):
3626 
    """
3627 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3628 
    need to be cancelled
4247 rajveer 3629 
 
4259 anupam.sin 3630 
    Parameters:
3631 
     - transactionId
3632 
     - refundedBy
3633 
     - reason
3634 
    """
3635 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3636 
    self.recv_refundTransaction()
3637 
 
3638 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3639 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3640 
    args = refundTransaction_args()
3641 
    args.transactionId = transactionId
3642 
    args.refundedBy = refundedBy
3643 
    args.reason = reason
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_refundTransaction(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = refundTransaction_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3658 
    if result.ex is not None:
3659 
      raise result.ex
3660 
    return
3661 
 
4324 mandeep.dh 3662 
  def updateShipmentAddress(self, orderId, addressId):
3663 
    """
3664 
    Updates shipment address of an order. Delivery and shipping date estimates
3665 
    etc. are also updated here.
3666 
 
3667 
    Throws TransactionServiceException in case address change is not
3668 
    possible due to certain reasons such as new pincode in address is
3669 
    not serviceable etc.
3670 
 
3671 
    Parameters:
3672 
     - orderId
3673 
     - addressId
3674 
    """
3675 
    self.send_updateShipmentAddress(orderId, addressId)
3676 
    self.recv_updateShipmentAddress()
3677 
 
3678 
  def send_updateShipmentAddress(self, orderId, addressId):
3679 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3680 
    args = updateShipmentAddress_args()
3681 
    args.orderId = orderId
3682 
    args.addressId = addressId
3683 
    args.write(self._oprot)
3684 
    self._oprot.writeMessageEnd()
3685 
    self._oprot.trans.flush()
3686 
 
3687 
  def recv_updateShipmentAddress(self, ):
3688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3689 
    if mtype == TMessageType.EXCEPTION:
3690 
      x = TApplicationException()
3691 
      x.read(self._iprot)
3692 
      self._iprot.readMessageEnd()
3693 
      raise x
3694 
    result = updateShipmentAddress_result()
3695 
    result.read(self._iprot)
3696 
    self._iprot.readMessageEnd()
3697 
    if result.ex is not None:
3698 
      raise result.ex
3699 
    return
3700 
 
4285 rajveer 3701 
  def acceptOrdersForItemId(self, itemId, inventory):
3702 
    """
3703 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3704 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3705 
 
4285 rajveer 3706 
    Parameters:
3707 
     - itemId
3708 
     - inventory
3709 
    """
3710 
    self.send_acceptOrdersForItemId(itemId, inventory)
3711 
    return self.recv_acceptOrdersForItemId()
3712 
 
3713 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3714 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3715 
    args = acceptOrdersForItemId_args()
3716 
    args.itemId = itemId
3717 
    args.inventory = inventory
3718 
    args.write(self._oprot)
3719 
    self._oprot.writeMessageEnd()
3720 
    self._oprot.trans.flush()
3721 
 
3722 
  def recv_acceptOrdersForItemId(self, ):
3723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3724 
    if mtype == TMessageType.EXCEPTION:
3725 
      x = TApplicationException()
3726 
      x.read(self._iprot)
3727 
      self._iprot.readMessageEnd()
3728 
      raise x
3729 
    result = acceptOrdersForItemId_result()
3730 
    result.read(self._iprot)
3731 
    self._iprot.readMessageEnd()
3732 
    if result.success is not None:
3733 
      return result.success
3734 
    if result.ex is not None:
3735 
      raise result.ex
3736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3737 
 
4369 rajveer 3738 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3739 
    """
3740 
    Parameters:
3741 
     - vendorId
3742 
     - itemId
3743 
     - quantity
3744 
     - estimate
4369 rajveer 3745 
     - isReminder
4303 rajveer 3746 
    """
4369 rajveer 3747 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3748 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3749 
 
4369 rajveer 3750 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3751 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3752 
    args = markOrdersAsPORaised_args()
3753 
    args.vendorId = vendorId
3754 
    args.itemId = itemId
3755 
    args.quantity = quantity
3756 
    args.estimate = estimate
4369 rajveer 3757 
    args.isReminder = isReminder
4303 rajveer 3758 
    args.write(self._oprot)
3759 
    self._oprot.writeMessageEnd()
3760 
    self._oprot.trans.flush()
3761 
 
3762 
  def recv_markOrdersAsPORaised(self, ):
3763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3764 
    if mtype == TMessageType.EXCEPTION:
3765 
      x = TApplicationException()
3766 
      x.read(self._iprot)
3767 
      self._iprot.readMessageEnd()
3768 
      raise x
3769 
    result = markOrdersAsPORaised_result()
3770 
    result.read(self._iprot)
3771 
    self._iprot.readMessageEnd()
3772 
    if result.ex is not None:
3773 
      raise result.ex
3774 
    return
3775 
 
4369 rajveer 3776 
  def markOrdersAsReversalInitiated(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_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3786 
    self.recv_markOrdersAsReversalInitiated()
3787 
 
4369 rajveer 3788 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3789 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3790 
    args = markOrdersAsReversalInitiated_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_markOrdersAsReversalInitiated(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 = markOrdersAsReversalInitiated_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 markOrdersAsNotAvailabke(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_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3824 
    self.recv_markOrdersAsNotAvailabke()
3825 
 
4369 rajveer 3826 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3827 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3828 
    args = markOrdersAsNotAvailabke_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_markOrdersAsNotAvailabke(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 = markOrdersAsNotAvailabke_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 markOrdersAsTimeout(self, vendorId):
3853 
    """
3854 
    Parameters:
3855 
     - vendorId
3856 
    """
3857 
    self.send_markOrdersAsTimeout(vendorId)
3858 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3859 
 
4369 rajveer 3860 
  def send_markOrdersAsTimeout(self, vendorId):
3861 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3862 
    args = markOrdersAsTimeout_args()
3863 
    args.vendorId = vendorId
3864 
    args.write(self._oprot)
3865 
    self._oprot.writeMessageEnd()
3866 
    self._oprot.trans.flush()
3867 
 
3868 
  def recv_markOrdersAsTimeout(self, ):
3869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3870 
    if mtype == TMessageType.EXCEPTION:
3871 
      x = TApplicationException()
3872 
      x.read(self._iprot)
3873 
      self._iprot.readMessageEnd()
3874 
      raise x
3875 
    result = markOrdersAsTimeout_result()
3876 
    result.read(self._iprot)
3877 
    self._iprot.readMessageEnd()
3878 
    if result.success is not None:
3879 
      return result.success
3880 
    if result.ex is not None:
3881 
      raise result.ex
3882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3883 
 
4662 rajveer 3884 
  def markOrderAsLostInTransit(self, orderId):
3885 
    """
3886 
    Mark order as LOST_IN_TRANSIT
3887 
 
3888 
    Parameters:
3889 
     - orderId
3890 
    """
3891 
    self.send_markOrderAsLostInTransit(orderId)
3892 
    return self.recv_markOrderAsLostInTransit()
3893 
 
3894 
  def send_markOrderAsLostInTransit(self, orderId):
3895 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3896 
    args = markOrderAsLostInTransit_args()
3897 
    args.orderId = orderId
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_markOrderAsLostInTransit(self, ):
3903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3904 
    if mtype == TMessageType.EXCEPTION:
3905 
      x = TApplicationException()
3906 
      x.read(self._iprot)
3907 
      self._iprot.readMessageEnd()
3908 
      raise x
3909 
    result = markOrderAsLostInTransit_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
3912 
    if result.success is not None:
3913 
      return result.success
3914 
    if result.ex is not None:
3915 
      raise result.ex
3916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3917 
 
4386 anupam.sin 3918 
  def getOrderForAwb(self, awb):
3919 
    """
3920 
    Returns the order corresponding to an AWB number
4369 rajveer 3921 
 
4386 anupam.sin 3922 
    Parameters:
3923 
     - awb
3924 
    """
3925 
    self.send_getOrderForAwb(awb)
3926 
    return self.recv_getOrderForAwb()
3927 
 
3928 
  def send_getOrderForAwb(self, awb):
3929 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3930 
    args = getOrderForAwb_args()
3931 
    args.awb = awb
3932 
    args.write(self._oprot)
3933 
    self._oprot.writeMessageEnd()
3934 
    self._oprot.trans.flush()
3935 
 
3936 
  def recv_getOrderForAwb(self, ):
3937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3938 
    if mtype == TMessageType.EXCEPTION:
3939 
      x = TApplicationException()
3940 
      x.read(self._iprot)
3941 
      self._iprot.readMessageEnd()
3942 
      raise x
3943 
    result = getOrderForAwb_result()
3944 
    result.read(self._iprot)
3945 
    self._iprot.readMessageEnd()
3946 
    if result.success is not None:
3947 
      return result.success
3948 
    if result.ex is not None:
3949 
      raise result.ex
3950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3951 
 
4506 phani.kuma 3952 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3953 
    """
3954 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3955 
 
4506 phani.kuma 3956 
    Parameters:
3957 
     - logistics_provider_id
3958 
     - order_status
3959 
    """
3960 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3961 
    return self.recv_getOrdersForProviderForStatus()
3962 
 
3963 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3964 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3965 
    args = getOrdersForProviderForStatus_args()
3966 
    args.logistics_provider_id = logistics_provider_id
3967 
    args.order_status = order_status
3968 
    args.write(self._oprot)
3969 
    self._oprot.writeMessageEnd()
3970 
    self._oprot.trans.flush()
3971 
 
3972 
  def recv_getOrdersForProviderForStatus(self, ):
3973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3974 
    if mtype == TMessageType.EXCEPTION:
3975 
      x = TApplicationException()
3976 
      x.read(self._iprot)
3977 
      self._iprot.readMessageEnd()
3978 
      raise x
3979 
    result = getOrdersForProviderForStatus_result()
3980 
    result.read(self._iprot)
3981 
    self._iprot.readMessageEnd()
3982 
    if result.success is not None:
3983 
      return result.success
3984 
    if result.ex is not None:
3985 
      raise result.ex
3986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3987 
 
4600 varun.gupt 3988 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3989 
    """
3990 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3991 
 
4600 varun.gupt 3992 
    Parameters:
3993 
     - vendorId
3994 
     - billingDateFrom
3995 
     - billingDateTo
3996 
    """
3997 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3998 
    return self.recv_getBilledOrdersForVendor()
3999 
 
4000 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4001 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4002 
    args = getBilledOrdersForVendor_args()
4003 
    args.vendorId = vendorId
4004 
    args.billingDateFrom = billingDateFrom
4005 
    args.billingDateTo = billingDateTo
4006 
    args.write(self._oprot)
4007 
    self._oprot.writeMessageEnd()
4008 
    self._oprot.trans.flush()
4009 
 
4010 
  def recv_getBilledOrdersForVendor(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 = getBilledOrdersForVendor_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, "getBilledOrdersForVendor failed: unknown result");
4025 
 
4607 rajveer 4026 
  def getSlippedSippingDateOrders(self, ):
4027 
    self.send_getSlippedSippingDateOrders()
4028 
    return self.recv_getSlippedSippingDateOrders()
4029 
 
4030 
  def send_getSlippedSippingDateOrders(self, ):
4031 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4032 
    args = getSlippedSippingDateOrders_args()
4033 
    args.write(self._oprot)
4034 
    self._oprot.writeMessageEnd()
4035 
    self._oprot.trans.flush()
4036 
 
4037 
  def recv_getSlippedSippingDateOrders(self, ):
4038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4039 
    if mtype == TMessageType.EXCEPTION:
4040 
      x = TApplicationException()
4041 
      x.read(self._iprot)
4042 
      self._iprot.readMessageEnd()
4043 
      raise x
4044 
    result = getSlippedSippingDateOrders_result()
4045 
    result.read(self._iprot)
4046 
    self._iprot.readMessageEnd()
4047 
    if result.success is not None:
4048 
      return result.success
4049 
    if result.ex is not None:
4050 
      raise result.ex
4051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4052 
 
4709 rajveer 4053 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4054 
    """
4055 
    Parameters:
4056 
     - cancelDateFrom
4057 
     - cancelDateTo
4058 
    """
4059 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4060 
    return self.recv_getCancelledOrders()
4061 
 
4062 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4063 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4064 
    args = getCancelledOrders_args()
4065 
    args.cancelDateFrom = cancelDateFrom
4066 
    args.cancelDateTo = cancelDateTo
4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_getCancelledOrders(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = getCancelledOrders_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
4081 
    if result.success is not None:
4082 
      return result.success
4083 
    if result.ex is not None:
4084 
      raise result.ex
4085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4086 
 
4600 varun.gupt 4087 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4088 
    """
4089 
    Parameters:
4090 
     - mapAWBAndAmount
4091 
    """
4092 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4093 
    self.recv_saveBluedartSettlements()
4094 
 
4095 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4096 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4097 
    args = saveBluedartSettlements_args()
4098 
    args.mapAWBAndAmount = mapAWBAndAmount
4099 
    args.write(self._oprot)
4100 
    self._oprot.writeMessageEnd()
4101 
    self._oprot.trans.flush()
4102 
 
4103 
  def recv_saveBluedartSettlements(self, ):
4104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4105 
    if mtype == TMessageType.EXCEPTION:
4106 
      x = TApplicationException()
4107 
      x.read(self._iprot)
4108 
      self._iprot.readMessageEnd()
4109 
      raise x
4110 
    result = saveBluedartSettlements_result()
4111 
    result.read(self._iprot)
4112 
    self._iprot.readMessageEnd()
4113 
    if result.ex is not None:
4114 
      raise result.ex
4115 
    return
4116 
 
4117 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4118 
    """
4119 
    Parameters:
4120 
     - settlementDate
4121 
     - paymentGatewayId
4122 
     - paymentId
4123 
     - serviceTax
4124 
     - otherCharges
4125 
     - netCollection
4126 
    """
4127 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4128 
    self.recv_savePaymentSettlements()
4129 
 
4130 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4131 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4132 
    args = savePaymentSettlements_args()
4133 
    args.settlementDate = settlementDate
4134 
    args.paymentGatewayId = paymentGatewayId
4135 
    args.paymentId = paymentId
4136 
    args.serviceTax = serviceTax
4137 
    args.otherCharges = otherCharges
4138 
    args.netCollection = netCollection
4139 
    args.write(self._oprot)
4140 
    self._oprot.writeMessageEnd()
4141 
    self._oprot.trans.flush()
4142 
 
4143 
  def recv_savePaymentSettlements(self, ):
4144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4145 
    if mtype == TMessageType.EXCEPTION:
4146 
      x = TApplicationException()
4147 
      x.read(self._iprot)
4148 
      self._iprot.readMessageEnd()
4149 
      raise x
4150 
    result = savePaymentSettlements_result()
4151 
    result.read(self._iprot)
4152 
    self._iprot.readMessageEnd()
4153 
    if result.ex is not None:
4154 
      raise result.ex
4155 
    return
4156 
 
4157 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4158 
    """
4159 
    Parameters:
4160 
     - settlementId
4161 
     - settlementDate
4162 
     - transactionDateFrom
4163 
     - transactionDateTo
4164 
     - amount
4165 
    """
4166 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4167 
    self.recv_saveEBSSettlementSummary()
4168 
 
4169 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4170 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4171 
    args = saveEBSSettlementSummary_args()
4172 
    args.settlementId = settlementId
4173 
    args.settlementDate = settlementDate
4174 
    args.transactionDateFrom = transactionDateFrom
4175 
    args.transactionDateTo = transactionDateTo
4176 
    args.amount = amount
4177 
    args.write(self._oprot)
4178 
    self._oprot.writeMessageEnd()
4179 
    self._oprot.trans.flush()
4180 
 
4181 
  def recv_saveEBSSettlementSummary(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 = saveEBSSettlementSummary_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 getSettlementForPaymentId(self, paymentId):
4196 
    """
4197 
    Parameters:
4198 
     - paymentId
4199 
    """
4200 
    self.send_getSettlementForPaymentId(paymentId)
4201 
    return self.recv_getSettlementForPaymentId()
4202 
 
4203 
  def send_getSettlementForPaymentId(self, paymentId):
4204 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4205 
    args = getSettlementForPaymentId_args()
4206 
    args.paymentId = paymentId
4207 
    args.write(self._oprot)
4208 
    self._oprot.writeMessageEnd()
4209 
    self._oprot.trans.flush()
4210 
 
4211 
  def recv_getSettlementForPaymentId(self, ):
4212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4213 
    if mtype == TMessageType.EXCEPTION:
4214 
      x = TApplicationException()
4215 
      x.read(self._iprot)
4216 
      self._iprot.readMessageEnd()
4217 
      raise x
4218 
    result = getSettlementForPaymentId_result()
4219 
    result.read(self._iprot)
4220 
    self._iprot.readMessageEnd()
4221 
    if result.success is not None:
4222 
      return result.success
4223 
    if result.ex is not None:
4224 
      raise result.ex
4225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4226 
 
4227 
  def getEBSSettlementSummaries(self, ):
4228 
    self.send_getEBSSettlementSummaries()
4229 
    return self.recv_getEBSSettlementSummaries()
4230 
 
4231 
  def send_getEBSSettlementSummaries(self, ):
4232 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4233 
    args = getEBSSettlementSummaries_args()
4234 
    args.write(self._oprot)
4235 
    self._oprot.writeMessageEnd()
4236 
    self._oprot.trans.flush()
4237 
 
4238 
  def recv_getEBSSettlementSummaries(self, ):
4239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4240 
    if mtype == TMessageType.EXCEPTION:
4241 
      x = TApplicationException()
4242 
      x.read(self._iprot)
4243 
      self._iprot.readMessageEnd()
4244 
      raise x
4245 
    result = getEBSSettlementSummaries_result()
4246 
    result.read(self._iprot)
4247 
    self._iprot.readMessageEnd()
4248 
    if result.success is not None:
4249 
      return result.success
4250 
    if result.ex is not None:
4251 
      raise result.ex
4252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4253 
 
4254 
  def markEBSSettlementUploaded(self, settlementId):
4255 
    """
4256 
    Parameters:
4257 
     - settlementId
4258 
    """
4259 
    self.send_markEBSSettlementUploaded(settlementId)
4260 
    self.recv_markEBSSettlementUploaded()
4261 
 
4262 
  def send_markEBSSettlementUploaded(self, settlementId):
4263 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4264 
    args = markEBSSettlementUploaded_args()
4265 
    args.settlementId = settlementId
4266 
    args.write(self._oprot)
4267 
    self._oprot.writeMessageEnd()
4268 
    self._oprot.trans.flush()
4269 
 
4270 
  def recv_markEBSSettlementUploaded(self, ):
4271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4272 
    if mtype == TMessageType.EXCEPTION:
4273 
      x = TApplicationException()
4274 
      x.read(self._iprot)
4275 
      self._iprot.readMessageEnd()
4276 
      raise x
4277 
    result = markEBSSettlementUploaded_result()
4278 
    result.read(self._iprot)
4279 
    self._iprot.readMessageEnd()
4280 
    if result.ex is not None:
4281 
      raise result.ex
4282 
    return
4283 
 
4284 
  def getEBSSettlementDate(self, settlementId):
4285 
    """
4286 
    Parameters:
4287 
     - settlementId
4288 
    """
4289 
    self.send_getEBSSettlementDate(settlementId)
4290 
    return self.recv_getEBSSettlementDate()
4291 
 
4292 
  def send_getEBSSettlementDate(self, settlementId):
4293 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4294 
    args = getEBSSettlementDate_args()
4295 
    args.settlementId = settlementId
4296 
    args.write(self._oprot)
4297 
    self._oprot.writeMessageEnd()
4298 
    self._oprot.trans.flush()
4299 
 
4300 
  def recv_getEBSSettlementDate(self, ):
4301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4302 
    if mtype == TMessageType.EXCEPTION:
4303 
      x = TApplicationException()
4304 
      x.read(self._iprot)
4305 
      self._iprot.readMessageEnd()
4306 
      raise x
4307 
    result = getEBSSettlementDate_result()
4308 
    result.read(self._iprot)
4309 
    self._iprot.readMessageEnd()
4310 
    if result.success is not None:
4311 
      return result.success
4312 
    if result.ex is not None:
4313 
      raise result.ex
4314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4315 
 
4715 varun.gupt 4316 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4317 
    """
4318 
    Parameters:
4319 
     - settlementDateFrom
4320 
     - settlementDateTo
4321 
     - isRefund
4322 
    """
4323 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4324 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4325 
 
4715 varun.gupt 4326 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4327 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4328 
    args = getSettlementsByDate_args()
4329 
    args.settlementDateFrom = settlementDateFrom
4330 
    args.settlementDateTo = settlementDateTo
4331 
    args.isRefund = isRefund
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_getSettlementsByDate(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = getSettlementsByDate_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.success is not None:
4347 
      return result.success
4348 
    if result.ex is not None:
4349 
      raise result.ex
4350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4351 
 
4352 
  def getReshippedOrderIds(self, orderIds):
4353 
    """
4354 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4355 
 
4356 
    Parameters:
4357 
     - orderIds
4358 
    """
4359 
    self.send_getReshippedOrderIds(orderIds)
4360 
    return self.recv_getReshippedOrderIds()
4361 
 
4362 
  def send_getReshippedOrderIds(self, orderIds):
4363 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4364 
    args = getReshippedOrderIds_args()
4365 
    args.orderIds = orderIds
4366 
    args.write(self._oprot)
4367 
    self._oprot.writeMessageEnd()
4368 
    self._oprot.trans.flush()
4369 
 
4370 
  def recv_getReshippedOrderIds(self, ):
4371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4372 
    if mtype == TMessageType.EXCEPTION:
4373 
      x = TApplicationException()
4374 
      x.read(self._iprot)
4375 
      self._iprot.readMessageEnd()
4376 
      raise x
4377 
    result = getReshippedOrderIds_result()
4378 
    result.read(self._iprot)
4379 
    self._iprot.readMessageEnd()
4380 
    if result.success is not None:
4381 
      return result.success
4382 
    if result.ex is not None:
4383 
      raise result.ex
4384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4385 
 
4757 mandeep.dh 4386 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4387 
    """
4388 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4389 
    the quantities for which the PO is raised.
4715 varun.gupt 4390 
 
4757 mandeep.dh 4391 
    Parameters:
4392 
     - itemIdQuantityMap
4393 
     - purchaseOrderId
4394 
     - warehouseId
4395 
    """
4396 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4397 
    self.recv_updateOrdersAsPORaised()
4398 
 
4399 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4400 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4401 
    args = updateOrdersAsPORaised_args()
4402 
    args.itemIdQuantityMap = itemIdQuantityMap
4403 
    args.purchaseOrderId = purchaseOrderId
4404 
    args.warehouseId = warehouseId
4405 
    args.write(self._oprot)
4406 
    self._oprot.writeMessageEnd()
4407 
    self._oprot.trans.flush()
4408 
 
4409 
  def recv_updateOrdersAsPORaised(self, ):
4410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4411 
    if mtype == TMessageType.EXCEPTION:
4412 
      x = TApplicationException()
4413 
      x.read(self._iprot)
4414 
      self._iprot.readMessageEnd()
4415 
      raise x
4416 
    result = updateOrdersAsPORaised_result()
4417 
    result.read(self._iprot)
4418 
    self._iprot.readMessageEnd()
4419 
    if result.ex is not None:
4420 
      raise result.ex
4421 
    return
4422 
 
4423 
 
3376 rajveer 4424 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4425 
  def __init__(self, handler):
3376 rajveer 4426 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4427 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4428 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4429 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4430 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4431 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4432 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4433 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4434 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4435 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4436 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4437 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4438 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4439 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4440 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4441 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4442 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4443 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4444 
    self._processMap["createOrder"] = Processor.process_createOrder
4445 
    self._processMap["getOrder"] = Processor.process_getOrder
4446 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4447 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4448 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4449 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4450 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4451 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4452 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4453 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4454 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4455 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4456 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4457 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4458 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4459 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4460 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4461 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4462 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4463 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4464 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4465 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4466 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4467 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4468 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4469 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4470 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4471 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4472 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4473 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4474 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4475 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4476 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4477 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4478 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4479 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4480 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4481 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4482 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4483 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4484 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4485 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4486 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4487 
    self._processMap["changeItem"] = Processor.process_changeItem
4488 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4489 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4490 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4491 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4492 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4493 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4494 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4495 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4496 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4497 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4498 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4499 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4500 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4501 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4502 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4503 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4504 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4505 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4506 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4507 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4508 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4509 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4510 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4511 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4512 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4513 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4514 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4515 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4516 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4517 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4518 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4519 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4520 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4521 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
94 ashish 4522 
 
4523 
  def process(self, iprot, oprot):
4524 
    (name, type, seqid) = iprot.readMessageBegin()
4525 
    if name not in self._processMap:
4526 
      iprot.skip(TType.STRUCT)
4527 
      iprot.readMessageEnd()
4528 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4529 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4530 
      x.write(oprot)
4531 
      oprot.writeMessageEnd()
4532 
      oprot.trans.flush()
4533 
      return
4534 
    else:
4535 
      self._processMap[name](self, seqid, iprot, oprot)
4536 
    return True
4537 
 
4538 
  def process_createTransaction(self, seqid, iprot, oprot):
4539 
    args = createTransaction_args()
4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
4542 
    result = createTransaction_result()
4543 
    try:
132 ashish 4544 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4545 
    except TransactionServiceException, ex:
4546 
      result.ex = ex
4547 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
4551 
 
4552 
  def process_getTransaction(self, seqid, iprot, oprot):
4553 
    args = getTransaction_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = getTransaction_result()
4557 
    try:
4558 
      result.success = self._handler.getTransaction(args.id)
4559 
    except TransactionServiceException, ex:
4560 
      result.ex = ex
4561 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
4565 
 
4566 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4567 
    args = getTransactionsForCustomer_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = getTransactionsForCustomer_result()
4571 
    try:
4572 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4573 
    except TransactionServiceException, ex:
4574 
      result.ex = ex
4575 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4576 
    result.write(oprot)
4577 
    oprot.writeMessageEnd()
4578 
    oprot.trans.flush()
4579 
 
132 ashish 4580 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4581 
    args = getTransactionsForShoppingCartId_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = getTransactionsForShoppingCartId_result()
4585 
    try:
4586 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4587 
    except TransactionServiceException, ex:
4588 
      result.ex = ex
4589 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
4593 
 
94 ashish 4594 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4595 
    args = getTransactionStatus_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = getTransactionStatus_result()
4599 
    try:
4600 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4601 
    except TransactionServiceException, ex:
4602 
      result.ex = ex
4603 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
4608 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4609 
    args = changeTransactionStatus_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = changeTransactionStatus_result()
4613 
    try:
4614 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4615 
    except TransactionServiceException, ex:
4616 
      result.ex = ex
4617 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
1398 varun.gupt 4622 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4623 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
1398 varun.gupt 4626 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4627 
    try:
1398 varun.gupt 4628 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4629 
    except TransactionServiceException, ex:
4630 
      result.ex = ex
1398 varun.gupt 4631 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4632 
    result.write(oprot)
4633 
    oprot.writeMessageEnd()
4634 
    oprot.trans.flush()
4635 
 
483 rajveer 4636 
  def process_getAllOrders(self, seqid, iprot, oprot):
4637 
    args = getAllOrders_args()
94 ashish 4638 
    args.read(iprot)
4639 
    iprot.readMessageEnd()
483 rajveer 4640 
    result = getAllOrders_result()
94 ashish 4641 
    try:
483 rajveer 4642 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4643 
    except TransactionServiceException, ex:
4644 
      result.ex = ex
483 rajveer 4645 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4133 chandransh 4650 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4651 
    args = getOrdersInBatch_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = getOrdersInBatch_result()
4655 
    try:
4656 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4657 
    except TransactionServiceException, ex:
4658 
      result.ex = ex
4659 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
4663 
 
4664 
  def process_getOrderCount(self, seqid, iprot, oprot):
4665 
    args = getOrderCount_args()
4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
4668 
    result = getOrderCount_result()
4669 
    try:
4670 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4671 
    except TransactionServiceException, ex:
4672 
      result.ex = ex
4673 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
999 varun.gupt 4678 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4679 
    args = getOrdersByBillingDate_args()
4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
4682 
    result = getOrdersByBillingDate_result()
4683 
    try:
4684 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4685 
    except TransactionServiceException, ex:
4686 
      result.ex = ex
4687 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
3427 chandransh 4692 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4693 
    args = getOrdersByShippingDate_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getOrdersByShippingDate_result()
4697 
    try:
3451 chandransh 4698 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4699 
    except TransactionServiceException, ex:
4700 
      result.ex = ex
4701 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4702 
    result.write(oprot)
4703 
    oprot.writeMessageEnd()
4704 
    oprot.trans.flush()
4705 
 
1382 varun.gupt 4706 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4707 
    args = getReturnableOrdersForCustomer_args()
4708 
    args.read(iprot)
4709 
    iprot.readMessageEnd()
4710 
    result = getReturnableOrdersForCustomer_result()
4711 
    try:
4712 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4713 
    except TransactionServiceException, ex:
4714 
      result.ex = ex
4715 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4721 
    args = getCancellableOrdersForCustomer_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getCancellableOrdersForCustomer_result()
4725 
    try:
4726 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4727 
    except TransactionServiceException, ex:
4728 
      result.ex = ex
4729 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
483 rajveer 4734 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4735 
    args = changeOrderStatus_args()
94 ashish 4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
483 rajveer 4738 
    result = changeOrderStatus_result()
94 ashish 4739 
    try:
483 rajveer 4740 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4741 
    except TransactionServiceException, ex:
4742 
      result.ex = ex
483 rajveer 4743 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
483 rajveer 4748 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4749 
    args = getOrdersForTransaction_args()
94 ashish 4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
483 rajveer 4752 
    result = getOrdersForTransaction_result()
94 ashish 4753 
    try:
1528 ankur.sing 4754 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4755 
    except TransactionServiceException, ex:
4756 
      result.ex = ex
483 rajveer 4757 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
483 rajveer 4762 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4763 
    args = getOrdersForCustomer_args()
94 ashish 4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
483 rajveer 4766 
    result = getOrdersForCustomer_result()
94 ashish 4767 
    try:
3014 chandransh 4768 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4769 
    except TransactionServiceException, ex:
4770 
      result.ex = ex
483 rajveer 4771 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
483 rajveer 4776 
  def process_createOrder(self, seqid, iprot, oprot):
4777 
    args = createOrder_args()
94 ashish 4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
483 rajveer 4780 
    result = createOrder_result()
94 ashish 4781 
    try:
483 rajveer 4782 
      result.success = self._handler.createOrder(args.order)
94 ashish 4783 
    except TransactionServiceException, ex:
4784 
      result.ex = ex
483 rajveer 4785 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
483 rajveer 4790 
  def process_getOrder(self, seqid, iprot, oprot):
4791 
    args = getOrder_args()
94 ashish 4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
483 rajveer 4794 
    result = getOrder_result()
94 ashish 4795 
    try:
483 rajveer 4796 
      result.success = self._handler.getOrder(args.id)
94 ashish 4797 
    except TransactionServiceException, ex:
4798 
      result.ex = ex
483 rajveer 4799 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
483 rajveer 4804 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4805 
    args = getLineItemsForOrder_args()
94 ashish 4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
483 rajveer 4808 
    result = getLineItemsForOrder_result()
94 ashish 4809 
    try:
483 rajveer 4810 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4811 
    except TransactionServiceException, ex:
4812 
      result.ex = ex
483 rajveer 4813 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
1528 ankur.sing 4818 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4819 
    args = getOrderForCustomer_args()
4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
4822 
    result = getOrderForCustomer_result()
4823 
    try:
4824 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4825 
    except TransactionServiceException, ex:
4826 
      result.ex = ex
4827 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
3064 chandransh 4832 
  def process_getAlerts(self, seqid, iprot, oprot):
4833 
    args = getAlerts_args()
4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
4836 
    result = getAlerts_result()
4444 rajveer 4837 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4838 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4839 
    result.write(oprot)
4840 
    oprot.writeMessageEnd()
4841 
    oprot.trans.flush()
4842 
 
4394 rajveer 4843 
  def process_addAlert(self, seqid, iprot, oprot):
4844 
    args = addAlert_args()
3064 chandransh 4845 
    args.read(iprot)
4846 
    iprot.readMessageEnd()
4394 rajveer 4847 
    result = addAlert_result()
4444 rajveer 4848 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4849 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
4853 
 
4444 rajveer 4854 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4855 
    args = markAlertsAsSeen_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    result = markAlertsAsSeen_result()
4859 
    self._handler.markAlertsAsSeen(args.warehouseId)
4860 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4861 
    result.write(oprot)
4862 
    oprot.writeMessageEnd()
4863 
    oprot.trans.flush()
4864 
 
3064 chandransh 4865 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4866 
    args = getValidOrderCount_args()
4867 
    args.read(iprot)
4868 
    iprot.readMessageEnd()
4869 
    result = getValidOrderCount_result()
4870 
    result.success = self._handler.getValidOrderCount()
4871 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
4876 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4877 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
4880 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4881 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4882 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4883 
    result.write(oprot)
4884 
    oprot.writeMessageEnd()
4885 
    oprot.trans.flush()
4886 
 
4887 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4888 
    args = getValidOrdersAmountRange_args()
4889 
    args.read(iprot)
4890 
    iprot.readMessageEnd()
4891 
    result = getValidOrdersAmountRange_result()
4892 
    result.success = self._handler.getValidOrdersAmountRange()
4893 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4894 
    result.write(oprot)
4895 
    oprot.writeMessageEnd()
4896 
    oprot.trans.flush()
4897 
 
4898 
  def process_getValidOrders(self, seqid, iprot, oprot):
4899 
    args = getValidOrders_args()
4900 
    args.read(iprot)
4901 
    iprot.readMessageEnd()
4902 
    result = getValidOrders_result()
4903 
    result.success = self._handler.getValidOrders(args.limit)
4904 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4905 
    result.write(oprot)
4906 
    oprot.writeMessageEnd()
4907 
    oprot.trans.flush()
4908 
 
1220 chandransh 4909 
  def process_batchOrders(self, seqid, iprot, oprot):
4910 
    args = batchOrders_args()
4911 
    args.read(iprot)
4912 
    iprot.readMessageEnd()
4913 
    result = batchOrders_result()
4914 
    try:
4915 
      result.success = self._handler.batchOrders(args.warehouseId)
4916 
    except TransactionServiceException, ex:
4917 
      result.ex = ex
4918 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4919 
    result.write(oprot)
4920 
    oprot.writeMessageEnd()
4921 
    oprot.trans.flush()
4922 
 
1208 chandransh 4923 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4924 
    args = markOrderAsOutOfStock_args()
4925 
    args.read(iprot)
4926 
    iprot.readMessageEnd()
4927 
    result = markOrderAsOutOfStock_result()
4928 
    try:
4929 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4930 
    except TransactionServiceException, ex:
4931 
      result.ex = ex
4932 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4933 
    result.write(oprot)
4934 
    oprot.writeMessageEnd()
4935 
    oprot.trans.flush()
4936 
 
3064 chandransh 4937 
  def process_verifyOrder(self, seqid, iprot, oprot):
4938 
    args = verifyOrder_args()
759 chandransh 4939 
    args.read(iprot)
4940 
    iprot.readMessageEnd()
3064 chandransh 4941 
    result = verifyOrder_result()
759 chandransh 4942 
    try:
3064 chandransh 4943 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4944 
    except TransactionServiceException, ex:
4945 
      result.ex = ex
3064 chandransh 4946 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
3064 chandransh 4951 
  def process_acceptOrder(self, seqid, iprot, oprot):
4952 
    args = acceptOrder_args()
1113 chandransh 4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
3064 chandransh 4955 
    result = acceptOrder_result()
1113 chandransh 4956 
    try:
3064 chandransh 4957 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4958 
    except TransactionServiceException, ex:
4959 
      result.ex = ex
3064 chandransh 4960 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
3064 chandransh 4965 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4966 
    args = addBillingDetails_args()
1135 chandransh 4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
3064 chandransh 4969 
    result = addBillingDetails_result()
1135 chandransh 4970 
    try:
4763 rajveer 4971 
      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 4972 
    except TransactionServiceException, ex:
4973 
      result.ex = ex
3064 chandransh 4974 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
4978 
 
4579 rajveer 4979 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4980 
    args = addInvoiceNumber_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = addInvoiceNumber_result()
4984 
    try:
4763 rajveer 4985 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 4986 
    except TransactionServiceException, ex:
4987 
      result.ex = ex
4988 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
3064 chandransh 4993 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4994 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
3064 chandransh 4997 
    result = markOrdersAsManifested_result()
4998 
    try:
4999 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5000 
    except TransactionServiceException, ex:
5001 
      result.ex = ex
5002 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
4410 rajveer 5007 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5008 
    args = markOrdersAsShippedFromWarehouse_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = markOrdersAsShippedFromWarehouse_result()
5012 
    try:
5013 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
5014 
    except TransactionServiceException, ex:
5015 
      result.ex = ex
5016 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
3064 chandransh 5021 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5022 
    args = markOrdersAsPickedUp_args()
304 ashish 5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
3064 chandransh 5025 
    result = markOrdersAsPickedUp_result()
5026 
    try:
5027 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5028 
    except TransactionServiceException, ex:
5029 
      result.ex = ex
5030 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
94 ashish 5034 
 
3064 chandransh 5035 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5036 
    args = markOrdersAsDelivered_args()
304 ashish 5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
3064 chandransh 5039 
    result = markOrdersAsDelivered_result()
5040 
    try:
5041 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5042 
    except TransactionServiceException, ex:
5043 
      result.ex = ex
5044 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
3064 chandransh 5049 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5050 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
3064 chandransh 5053 
    result = markOrdersAsFailed_result()
5054 
    try:
5055 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5056 
    except TransactionServiceException, ex:
5057 
      result.ex = ex
5058 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
304 ashish 5062 
 
3064 chandransh 5063 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5064 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
3064 chandransh 5067 
    result = updateNonDeliveryReason_result()
5068 
    try:
4581 phani.kuma 5069 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5070 
    except TransactionServiceException, ex:
5071 
      result.ex = ex
5072 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
1596 ankur.sing 5076 
 
3064 chandransh 5077 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5078 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
3064 chandransh 5081 
    result = getUndeliveredOrders_result()
5082 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5083 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5084 
    result.write(oprot)
5085 
    oprot.writeMessageEnd()
5086 
    oprot.trans.flush()
5087 
 
2536 chandransh 5088 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5089 
    args = toggleDOAFlag_args()
5090 
    args.read(iprot)
5091 
    iprot.readMessageEnd()
5092 
    result = toggleDOAFlag_result()
5093 
    try:
5094 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5095 
    except TransactionServiceException, ex:
5096 
      result.ex = ex
5097 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
1886 ankur.sing 5101 
 
4712 rajveer 5102 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5103 
    args = markOrderAsDelivered_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = markOrderAsDelivered_result()
5107 
    try:
5108 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5109 
    except TransactionServiceException, ex:
5110 
      result.ex = ex
5111 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5112 
    result.write(oprot)
5113 
    oprot.writeMessageEnd()
5114 
    oprot.trans.flush()
5115 
 
4454 rajveer 5116 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5117 
    args = markOrderDoaRequestReceived_args()
5118 
    args.read(iprot)
5119 
    iprot.readMessageEnd()
5120 
    result = markOrderDoaRequestReceived_result()
5121 
    try:
5122 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5123 
    except TransactionServiceException, ex:
5124 
      result.ex = ex
5125 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
5130 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5131 
    args = markOrderDoaRequestAuthorized_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = markOrderDoaRequestAuthorized_result()
5135 
    try:
5136 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5137 
    except TransactionServiceException, ex:
5138 
      result.ex = ex
5139 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
5143 
 
4488 rajveer 5144 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5145 
    args = markOrderReturnRequestReceived_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = markOrderReturnRequestReceived_result()
5149 
    try:
5150 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5151 
    except TransactionServiceException, ex:
5152 
      result.ex = ex
5153 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5154 
    result.write(oprot)
5155 
    oprot.writeMessageEnd()
5156 
    oprot.trans.flush()
5157 
 
5158 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5159 
    args = markOrderReturnRequestAuthorized_args()
5160 
    args.read(iprot)
5161 
    iprot.readMessageEnd()
5162 
    result = markOrderReturnRequestAuthorized_result()
5163 
    try:
5164 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5165 
    except TransactionServiceException, ex:
5166 
      result.ex = ex
5167 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5168 
    result.write(oprot)
5169 
    oprot.writeMessageEnd()
5170 
    oprot.trans.flush()
5171 
 
2536 chandransh 5172 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5173 
    args = requestPickupNumber_args()
5174 
    args.read(iprot)
5175 
    iprot.readMessageEnd()
5176 
    result = requestPickupNumber_result()
5177 
    try:
4579 rajveer 5178 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5179 
    except TransactionServiceException, ex:
5180 
      result.ex = ex
5181 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
5186 
  def process_authorizePickup(self, seqid, iprot, oprot):
5187 
    args = authorizePickup_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = authorizePickup_result()
5191 
    try:
4602 rajveer 5192 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5193 
    except TransactionServiceException, ex:
5194 
      result.ex = ex
5195 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5196 
    result.write(oprot)
5197 
    oprot.writeMessageEnd()
5198 
    oprot.trans.flush()
5199 
 
2764 chandransh 5200 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5201 
    args = markDoasAsPickedUp_args()
5202 
    args.read(iprot)
5203 
    iprot.readMessageEnd()
5204 
    result = markDoasAsPickedUp_result()
5205 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5206 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5207 
    result.write(oprot)
5208 
    oprot.writeMessageEnd()
5209 
    oprot.trans.flush()
5210 
 
4741 phani.kuma 5211 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5212 
    args = markReturnOrdersAsPickedUp_args()
5213 
    args.read(iprot)
5214 
    iprot.readMessageEnd()
5215 
    result = markReturnOrdersAsPickedUp_result()
5216 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5217 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5218 
    result.write(oprot)
5219 
    oprot.writeMessageEnd()
5220 
    oprot.trans.flush()
5221 
 
2616 chandransh 5222 
  def process_receiveReturn(self, seqid, iprot, oprot):
5223 
    args = receiveReturn_args()
2591 chandransh 5224 
    args.read(iprot)
5225 
    iprot.readMessageEnd()
2616 chandransh 5226 
    result = receiveReturn_result()
2591 chandransh 5227 
    try:
4479 rajveer 5228 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5229 
    except TransactionServiceException, ex:
5230 
      result.ex = ex
2616 chandransh 5231 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5232 
    result.write(oprot)
5233 
    oprot.writeMessageEnd()
5234 
    oprot.trans.flush()
2536 chandransh 5235 
 
2591 chandransh 5236 
  def process_validateDoa(self, seqid, iprot, oprot):
5237 
    args = validateDoa_args()
5238 
    args.read(iprot)
5239 
    iprot.readMessageEnd()
5240 
    result = validateDoa_result()
5241 
    try:
5242 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5243 
    except TransactionServiceException, ex:
5244 
      result.ex = ex
5245 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5246 
    result.write(oprot)
5247 
    oprot.writeMessageEnd()
5248 
    oprot.trans.flush()
5249 
 
4495 rajveer 5250 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5251 
    args = validateReturnProduct_args()
5252 
    args.read(iprot)
5253 
    iprot.readMessageEnd()
5254 
    result = validateReturnProduct_result()
5255 
    try:
5256 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5257 
    except TransactionServiceException, ex:
5258 
      result.ex = ex
5259 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
5263 
 
2616 chandransh 5264 
  def process_reshipOrder(self, seqid, iprot, oprot):
5265 
    args = reshipOrder_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = reshipOrder_result()
5269 
    try:
5270 
      result.success = self._handler.reshipOrder(args.orderId)
5271 
    except TransactionServiceException, ex:
5272 
      result.ex = ex
5273 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5274 
    result.write(oprot)
5275 
    oprot.writeMessageEnd()
5276 
    oprot.trans.flush()
2591 chandransh 5277 
 
2616 chandransh 5278 
  def process_refundOrder(self, seqid, iprot, oprot):
5279 
    args = refundOrder_args()
5280 
    args.read(iprot)
5281 
    iprot.readMessageEnd()
5282 
    result = refundOrder_result()
5283 
    try:
3226 chandransh 5284 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5285 
    except TransactionServiceException, ex:
5286 
      result.ex = ex
5287 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
5291 
 
2690 chandransh 5292 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5293 
    args = getReturnOrders_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getReturnOrders_result()
5297 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5298 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
2616 chandransh 5302 
 
2700 chandransh 5303 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5304 
    args = getReturnOrder_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = getReturnOrder_result()
5308 
    try:
5309 
      result.success = self._handler.getReturnOrder(args.id)
5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
5312 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
5316 
 
2690 chandransh 5317 
  def process_processReturn(self, seqid, iprot, oprot):
5318 
    args = processReturn_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = processReturn_result()
5322 
    try:
5323 
      self._handler.processReturn(args.returnOrderId)
5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
5326 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
5330 
 
3451 chandransh 5331 
  def process_updateWeight(self, seqid, iprot, oprot):
5332 
    args = updateWeight_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = updateWeight_result()
5336 
    try:
5337 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
5340 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
2819 chandransh 5344 
 
3469 chandransh 5345 
  def process_changeItem(self, seqid, iprot, oprot):
5346 
    args = changeItem_args()
5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
5349 
    result = changeItem_result()
5350 
    try:
5351 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5352 
    except TransactionServiceException, ex:
5353 
      result.ex = ex
5354 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
3451 chandransh 5358 
 
3469 chandransh 5359 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5360 
    args = shiftToWarehouse_args()
5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
5363 
    result = shiftToWarehouse_result()
5364 
    try:
5365 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
5368 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
3553 chandransh 5373 
  def process_addDelayReason(self, seqid, iprot, oprot):
5374 
    args = addDelayReason_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = addDelayReason_result()
5378 
    try:
4647 rajveer 5379 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
5382 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
3469 chandransh 5386 
 
3956 chandransh 5387 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5388 
    args = reconcileCodCollection_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = reconcileCodCollection_result()
5392 
    try:
5393 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5394 
    except TransactionServiceException, ex:
5395 
      result.ex = ex
5396 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
3553 chandransh 5400 
 
4008 mandeep.dh 5401 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5402 
    args = getTransactionsRequiringExtraProcessing_args()
5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
5405 
    result = getTransactionsRequiringExtraProcessing_result()
5406 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5407 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
3956 chandransh 5411 
 
4008 mandeep.dh 5412 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5413 
    args = markTransactionAsProcessed_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = markTransactionAsProcessed_result()
5417 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5418 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5419 
    result.write(oprot)
5420 
    oprot.writeMessageEnd()
5421 
    oprot.trans.flush()
5422 
 
4018 chandransh 5423 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5424 
    args = getItemWiseRiskyOrdersCount_args()
5425 
    args.read(iprot)
5426 
    iprot.readMessageEnd()
5427 
    result = getItemWiseRiskyOrdersCount_result()
5428 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5429 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5430 
    result.write(oprot)
5431 
    oprot.writeMessageEnd()
5432 
    oprot.trans.flush()
4008 mandeep.dh 5433 
 
4295 varun.gupt 5434 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5435 
    args = getOrdersForItemIds_args()
5436 
    args.read(iprot)
5437 
    iprot.readMessageEnd()
5438 
    result = getOrdersForItemIds_result()
5439 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5440 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5441 
    result.write(oprot)
5442 
    oprot.writeMessageEnd()
5443 
    oprot.trans.flush()
5444 
 
4247 rajveer 5445 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5446 
    args = markOrderCancellationRequestReceived_args()
5447 
    args.read(iprot)
5448 
    iprot.readMessageEnd()
5449 
    result = markOrderCancellationRequestReceived_result()
5450 
    try:
5451 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5452 
    except TransactionServiceException, ex:
5453 
      result.ex = ex
5454 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5455 
    result.write(oprot)
5456 
    oprot.writeMessageEnd()
5457 
    oprot.trans.flush()
4018 chandransh 5458 
 
4247 rajveer 5459 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5460 
    args = markOrderCancellationRequestConfirmed_args()
5461 
    args.read(iprot)
5462 
    iprot.readMessageEnd()
5463 
    result = markOrderCancellationRequestConfirmed_result()
5464 
    try:
5465 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5466 
    except TransactionServiceException, ex:
5467 
      result.ex = ex
5468 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5469 
    result.write(oprot)
5470 
    oprot.writeMessageEnd()
5471 
    oprot.trans.flush()
5472 
 
5473 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5474 
    args = markOrderCancellationRequestDenied_args()
5475 
    args.read(iprot)
5476 
    iprot.readMessageEnd()
5477 
    result = markOrderCancellationRequestDenied_result()
5478 
    try:
5479 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5480 
    except TransactionServiceException, ex:
5481 
      result.ex = ex
5482 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
5486 
 
4258 rajveer 5487 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5488 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
4258 rajveer 5491 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5492 
    try:
4258 rajveer 5493 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5494 
    except TransactionServiceException, ex:
5495 
      result.ex = ex
4258 rajveer 5496 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5497 
    result.write(oprot)
5498 
    oprot.writeMessageEnd()
5499 
    oprot.trans.flush()
5500 
 
4259 anupam.sin 5501 
  def process_refundTransaction(self, seqid, iprot, oprot):
5502 
    args = refundTransaction_args()
5503 
    args.read(iprot)
5504 
    iprot.readMessageEnd()
5505 
    result = refundTransaction_result()
5506 
    try:
5507 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5508 
    except TransactionServiceException, ex:
5509 
      result.ex = ex
5510 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5511 
    result.write(oprot)
5512 
    oprot.writeMessageEnd()
5513 
    oprot.trans.flush()
4247 rajveer 5514 
 
4324 mandeep.dh 5515 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5516 
    args = updateShipmentAddress_args()
5517 
    args.read(iprot)
5518 
    iprot.readMessageEnd()
5519 
    result = updateShipmentAddress_result()
5520 
    try:
5521 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5522 
    except TransactionServiceException, ex:
5523 
      result.ex = ex
5524 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5525 
    result.write(oprot)
5526 
    oprot.writeMessageEnd()
5527 
    oprot.trans.flush()
5528 
 
4285 rajveer 5529 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5530 
    args = acceptOrdersForItemId_args()
5531 
    args.read(iprot)
5532 
    iprot.readMessageEnd()
5533 
    result = acceptOrdersForItemId_result()
5534 
    try:
5535 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5536 
    except TransactionServiceException, ex:
5537 
      result.ex = ex
5538 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5539 
    result.write(oprot)
5540 
    oprot.writeMessageEnd()
5541 
    oprot.trans.flush()
4259 anupam.sin 5542 
 
4303 rajveer 5543 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5544 
    args = markOrdersAsPORaised_args()
5545 
    args.read(iprot)
5546 
    iprot.readMessageEnd()
5547 
    result = markOrdersAsPORaised_result()
5548 
    try:
4369 rajveer 5549 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5550 
    except TransactionServiceException, ex:
5551 
      result.ex = ex
5552 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5553 
    result.write(oprot)
5554 
    oprot.writeMessageEnd()
5555 
    oprot.trans.flush()
4285 rajveer 5556 
 
4303 rajveer 5557 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5558 
    args = markOrdersAsReversalInitiated_args()
5559 
    args.read(iprot)
5560 
    iprot.readMessageEnd()
5561 
    result = markOrdersAsReversalInitiated_result()
5562 
    try:
4369 rajveer 5563 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5564 
    except TransactionServiceException, ex:
5565 
      result.ex = ex
5566 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
5571 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5572 
    args = markOrdersAsNotAvailabke_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = markOrdersAsNotAvailabke_result()
5576 
    try:
4369 rajveer 5577 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5578 
    except TransactionServiceException, ex:
5579 
      result.ex = ex
5580 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
4369 rajveer 5585 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5586 
    args = markOrdersAsTimeout_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = markOrdersAsTimeout_result()
5590 
    try:
5591 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5592 
    except TransactionServiceException, ex:
5593 
      result.ex = ex
5594 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5595 
    result.write(oprot)
5596 
    oprot.writeMessageEnd()
5597 
    oprot.trans.flush()
4303 rajveer 5598 
 
4662 rajveer 5599 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5600 
    args = markOrderAsLostInTransit_args()
5601 
    args.read(iprot)
5602 
    iprot.readMessageEnd()
5603 
    result = markOrderAsLostInTransit_result()
5604 
    try:
5605 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5606 
    except TransactionServiceException, ex:
5607 
      result.ex = ex
5608 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5609 
    result.write(oprot)
5610 
    oprot.writeMessageEnd()
5611 
    oprot.trans.flush()
5612 
 
4386 anupam.sin 5613 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5614 
    args = getOrderForAwb_args()
5615 
    args.read(iprot)
5616 
    iprot.readMessageEnd()
5617 
    result = getOrderForAwb_result()
5618 
    try:
5619 
      result.success = self._handler.getOrderForAwb(args.awb)
5620 
    except TransactionServiceException, ex:
5621 
      result.ex = ex
5622 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5623 
    result.write(oprot)
5624 
    oprot.writeMessageEnd()
5625 
    oprot.trans.flush()
4369 rajveer 5626 
 
4506 phani.kuma 5627 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5628 
    args = getOrdersForProviderForStatus_args()
5629 
    args.read(iprot)
5630 
    iprot.readMessageEnd()
5631 
    result = getOrdersForProviderForStatus_result()
5632 
    try:
5633 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5634 
    except TransactionServiceException, ex:
5635 
      result.ex = ex
5636 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5637 
    result.write(oprot)
5638 
    oprot.writeMessageEnd()
5639 
    oprot.trans.flush()
4386 anupam.sin 5640 
 
4600 varun.gupt 5641 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5642 
    args = getBilledOrdersForVendor_args()
5643 
    args.read(iprot)
5644 
    iprot.readMessageEnd()
5645 
    result = getBilledOrdersForVendor_result()
5646 
    try:
5647 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5648 
    except TransactionServiceException, ex:
5649 
      result.ex = ex
5650 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5651 
    result.write(oprot)
5652 
    oprot.writeMessageEnd()
5653 
    oprot.trans.flush()
4506 phani.kuma 5654 
 
4607 rajveer 5655 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5656 
    args = getSlippedSippingDateOrders_args()
5657 
    args.read(iprot)
5658 
    iprot.readMessageEnd()
5659 
    result = getSlippedSippingDateOrders_result()
5660 
    try:
5661 
      result.success = self._handler.getSlippedSippingDateOrders()
5662 
    except TransactionServiceException, ex:
5663 
      result.ex = ex
5664 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5665 
    result.write(oprot)
5666 
    oprot.writeMessageEnd()
5667 
    oprot.trans.flush()
5668 
 
4709 rajveer 5669 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5670 
    args = getCancelledOrders_args()
5671 
    args.read(iprot)
5672 
    iprot.readMessageEnd()
5673 
    result = getCancelledOrders_result()
5674 
    try:
5675 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5676 
    except TransactionServiceException, ex:
5677 
      result.ex = ex
5678 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5679 
    result.write(oprot)
5680 
    oprot.writeMessageEnd()
5681 
    oprot.trans.flush()
5682 
 
4600 varun.gupt 5683 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5684 
    args = saveBluedartSettlements_args()
5685 
    args.read(iprot)
5686 
    iprot.readMessageEnd()
5687 
    result = saveBluedartSettlements_result()
5688 
    try:
5689 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5690 
    except TransactionServiceException, ex:
5691 
      result.ex = ex
5692 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5693 
    result.write(oprot)
5694 
    oprot.writeMessageEnd()
5695 
    oprot.trans.flush()
5696 
 
5697 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5698 
    args = savePaymentSettlements_args()
5699 
    args.read(iprot)
5700 
    iprot.readMessageEnd()
5701 
    result = savePaymentSettlements_result()
5702 
    try:
5703 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5704 
    except TransactionServiceException, ex:
5705 
      result.ex = ex
5706 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5707 
    result.write(oprot)
5708 
    oprot.writeMessageEnd()
5709 
    oprot.trans.flush()
5710 
 
5711 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5712 
    args = saveEBSSettlementSummary_args()
5713 
    args.read(iprot)
5714 
    iprot.readMessageEnd()
5715 
    result = saveEBSSettlementSummary_result()
5716 
    try:
5717 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5718 
    except TransactionServiceException, ex:
5719 
      result.ex = ex
5720 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5721 
    result.write(oprot)
5722 
    oprot.writeMessageEnd()
5723 
    oprot.trans.flush()
5724 
 
5725 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5726 
    args = getSettlementForPaymentId_args()
5727 
    args.read(iprot)
5728 
    iprot.readMessageEnd()
5729 
    result = getSettlementForPaymentId_result()
5730 
    try:
5731 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5732 
    except TransactionServiceException, ex:
5733 
      result.ex = ex
5734 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5735 
    result.write(oprot)
5736 
    oprot.writeMessageEnd()
5737 
    oprot.trans.flush()
5738 
 
5739 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5740 
    args = getEBSSettlementSummaries_args()
5741 
    args.read(iprot)
5742 
    iprot.readMessageEnd()
5743 
    result = getEBSSettlementSummaries_result()
5744 
    try:
5745 
      result.success = self._handler.getEBSSettlementSummaries()
5746 
    except TransactionServiceException, ex:
5747 
      result.ex = ex
5748 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5749 
    result.write(oprot)
5750 
    oprot.writeMessageEnd()
5751 
    oprot.trans.flush()
5752 
 
5753 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5754 
    args = markEBSSettlementUploaded_args()
5755 
    args.read(iprot)
5756 
    iprot.readMessageEnd()
5757 
    result = markEBSSettlementUploaded_result()
5758 
    try:
5759 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5760 
    except TransactionServiceException, ex:
5761 
      result.ex = ex
5762 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5763 
    result.write(oprot)
5764 
    oprot.writeMessageEnd()
5765 
    oprot.trans.flush()
5766 
 
5767 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5768 
    args = getEBSSettlementDate_args()
5769 
    args.read(iprot)
5770 
    iprot.readMessageEnd()
5771 
    result = getEBSSettlementDate_result()
5772 
    try:
5773 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5774 
    except TransactionServiceException, ex:
5775 
      result.ex = ex
5776 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5777 
    result.write(oprot)
5778 
    oprot.writeMessageEnd()
5779 
    oprot.trans.flush()
5780 
 
4715 varun.gupt 5781 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5782 
    args = getSettlementsByDate_args()
5783 
    args.read(iprot)
5784 
    iprot.readMessageEnd()
5785 
    result = getSettlementsByDate_result()
5786 
    try:
5787 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5788 
    except TransactionServiceException, ex:
5789 
      result.ex = ex
5790 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5791 
    result.write(oprot)
5792 
    oprot.writeMessageEnd()
5793 
    oprot.trans.flush()
4600 varun.gupt 5794 
 
4715 varun.gupt 5795 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5796 
    args = getReshippedOrderIds_args()
5797 
    args.read(iprot)
5798 
    iprot.readMessageEnd()
5799 
    result = getReshippedOrderIds_result()
5800 
    try:
5801 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5802 
    except TransactionServiceException, ex:
5803 
      result.ex = ex
5804 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5805 
    result.write(oprot)
5806 
    oprot.writeMessageEnd()
5807 
    oprot.trans.flush()
5808 
 
4757 mandeep.dh 5809 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5810 
    args = updateOrdersAsPORaised_args()
5811 
    args.read(iprot)
5812 
    iprot.readMessageEnd()
5813 
    result = updateOrdersAsPORaised_result()
5814 
    try:
5815 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5816 
    except TransactionServiceException, ex:
5817 
      result.ex = ex
5818 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
4715 varun.gupt 5822 
 
4757 mandeep.dh 5823 
 
94 ashish 5824 
# HELPER FUNCTIONS AND STRUCTURES
5825 
 
5826 
class createTransaction_args:
5827 
  """
5828 
  Attributes:
5829 
   - transaction
5830 
  """
5831 
 
5832 
  thrift_spec = (
5833 
    None, # 0
5834 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5835 
  )
5836 
 
5837 
  def __init__(self, transaction=None,):
5838 
    self.transaction = transaction
5839 
 
5840 
  def read(self, iprot):
5841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5843 
      return
5844 
    iprot.readStructBegin()
5845 
    while True:
5846 
      (fname, ftype, fid) = iprot.readFieldBegin()
5847 
      if ftype == TType.STOP:
5848 
        break
5849 
      if fid == 1:
5850 
        if ftype == TType.STRUCT:
5851 
          self.transaction = Transaction()
5852 
          self.transaction.read(iprot)
5853 
        else:
5854 
          iprot.skip(ftype)
5855 
      else:
5856 
        iprot.skip(ftype)
5857 
      iprot.readFieldEnd()
5858 
    iprot.readStructEnd()
5859 
 
5860 
  def write(self, oprot):
5861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5863 
      return
5864 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5865 
    if self.transaction is not None:
94 ashish 5866 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5867 
      self.transaction.write(oprot)
5868 
      oprot.writeFieldEnd()
5869 
    oprot.writeFieldStop()
5870 
    oprot.writeStructEnd()
5871 
 
3431 rajveer 5872 
  def validate(self):
5873 
    return
5874 
 
5875 
 
94 ashish 5876 
  def __repr__(self):
5877 
    L = ['%s=%r' % (key, value)
5878 
      for key, value in self.__dict__.iteritems()]
5879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5880 
 
5881 
  def __eq__(self, other):
5882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5883 
 
5884 
  def __ne__(self, other):
5885 
    return not (self == other)
5886 
 
5887 
class createTransaction_result:
5888 
  """
5889 
  Attributes:
132 ashish 5890 
   - success
94 ashish 5891 
   - ex
5892 
  """
5893 
 
5894 
  thrift_spec = (
132 ashish 5895 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5897 
  )
5898 
 
132 ashish 5899 
  def __init__(self, success=None, ex=None,):
5900 
    self.success = success
94 ashish 5901 
    self.ex = ex
5902 
 
5903 
  def read(self, iprot):
5904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5906 
      return
5907 
    iprot.readStructBegin()
5908 
    while True:
5909 
      (fname, ftype, fid) = iprot.readFieldBegin()
5910 
      if ftype == TType.STOP:
5911 
        break
132 ashish 5912 
      if fid == 0:
5913 
        if ftype == TType.I64:
5914 
          self.success = iprot.readI64();
5915 
        else:
5916 
          iprot.skip(ftype)
5917 
      elif fid == 1:
94 ashish 5918 
        if ftype == TType.STRUCT:
5919 
          self.ex = TransactionServiceException()
5920 
          self.ex.read(iprot)
5921 
        else:
5922 
          iprot.skip(ftype)
5923 
      else:
5924 
        iprot.skip(ftype)
5925 
      iprot.readFieldEnd()
5926 
    iprot.readStructEnd()
5927 
 
5928 
  def write(self, oprot):
5929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5931 
      return
5932 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5933 
    if self.success is not None:
132 ashish 5934 
      oprot.writeFieldBegin('success', TType.I64, 0)
5935 
      oprot.writeI64(self.success)
5936 
      oprot.writeFieldEnd()
3431 rajveer 5937 
    if self.ex is not None:
94 ashish 5938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5939 
      self.ex.write(oprot)
5940 
      oprot.writeFieldEnd()
5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
3431 rajveer 5944 
  def validate(self):
5945 
    return
5946 
 
5947 
 
94 ashish 5948 
  def __repr__(self):
5949 
    L = ['%s=%r' % (key, value)
5950 
      for key, value in self.__dict__.iteritems()]
5951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5952 
 
5953 
  def __eq__(self, other):
5954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5955 
 
5956 
  def __ne__(self, other):
5957 
    return not (self == other)
5958 
 
5959 
class getTransaction_args:
5960 
  """
5961 
  Attributes:
5962 
   - id
5963 
  """
5964 
 
5965 
  thrift_spec = (
5966 
    None, # 0
5967 
    (1, TType.I64, 'id', None, None, ), # 1
5968 
  )
5969 
 
5970 
  def __init__(self, id=None,):
5971 
    self.id = id
5972 
 
5973 
  def read(self, iprot):
5974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5976 
      return
5977 
    iprot.readStructBegin()
5978 
    while True:
5979 
      (fname, ftype, fid) = iprot.readFieldBegin()
5980 
      if ftype == TType.STOP:
5981 
        break
5982 
      if fid == 1:
5983 
        if ftype == TType.I64:
5984 
          self.id = iprot.readI64();
5985 
        else:
5986 
          iprot.skip(ftype)
5987 
      else:
5988 
        iprot.skip(ftype)
5989 
      iprot.readFieldEnd()
5990 
    iprot.readStructEnd()
5991 
 
5992 
  def write(self, oprot):
5993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5995 
      return
5996 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5997 
    if self.id is not None:
94 ashish 5998 
      oprot.writeFieldBegin('id', TType.I64, 1)
5999 
      oprot.writeI64(self.id)
6000 
      oprot.writeFieldEnd()
6001 
    oprot.writeFieldStop()
6002 
    oprot.writeStructEnd()
6003 
 
3431 rajveer 6004 
  def validate(self):
6005 
    return
6006 
 
6007 
 
94 ashish 6008 
  def __repr__(self):
6009 
    L = ['%s=%r' % (key, value)
6010 
      for key, value in self.__dict__.iteritems()]
6011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6012 
 
6013 
  def __eq__(self, other):
6014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6015 
 
6016 
  def __ne__(self, other):
6017 
    return not (self == other)
6018 
 
6019 
class getTransaction_result:
6020 
  """
6021 
  Attributes:
6022 
   - success
6023 
   - ex
6024 
  """
6025 
 
6026 
  thrift_spec = (
6027 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6029 
  )
6030 
 
6031 
  def __init__(self, success=None, ex=None,):
6032 
    self.success = success
6033 
    self.ex = ex
6034 
 
6035 
  def read(self, iprot):
6036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6038 
      return
6039 
    iprot.readStructBegin()
6040 
    while True:
6041 
      (fname, ftype, fid) = iprot.readFieldBegin()
6042 
      if ftype == TType.STOP:
6043 
        break
6044 
      if fid == 0:
6045 
        if ftype == TType.STRUCT:
6046 
          self.success = Transaction()
6047 
          self.success.read(iprot)
6048 
        else:
6049 
          iprot.skip(ftype)
6050 
      elif fid == 1:
6051 
        if ftype == TType.STRUCT:
6052 
          self.ex = TransactionServiceException()
6053 
          self.ex.read(iprot)
6054 
        else:
6055 
          iprot.skip(ftype)
6056 
      else:
6057 
        iprot.skip(ftype)
6058 
      iprot.readFieldEnd()
6059 
    iprot.readStructEnd()
6060 
 
6061 
  def write(self, oprot):
6062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6064 
      return
6065 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6066 
    if self.success is not None:
94 ashish 6067 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6068 
      self.success.write(oprot)
6069 
      oprot.writeFieldEnd()
3431 rajveer 6070 
    if self.ex is not None:
94 ashish 6071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6072 
      self.ex.write(oprot)
6073 
      oprot.writeFieldEnd()
6074 
    oprot.writeFieldStop()
6075 
    oprot.writeStructEnd()
6076 
 
3431 rajveer 6077 
  def validate(self):
6078 
    return
6079 
 
6080 
 
94 ashish 6081 
  def __repr__(self):
6082 
    L = ['%s=%r' % (key, value)
6083 
      for key, value in self.__dict__.iteritems()]
6084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6085 
 
6086 
  def __eq__(self, other):
6087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6088 
 
6089 
  def __ne__(self, other):
6090 
    return not (self == other)
6091 
 
6092 
class getTransactionsForCustomer_args:
6093 
  """
6094 
  Attributes:
6095 
   - customerId
6096 
   - from_date
6097 
   - to_date
6098 
   - status
6099 
  """
6100 
 
6101 
  thrift_spec = (
6102 
    None, # 0
6103 
    (1, TType.I64, 'customerId', None, None, ), # 1
6104 
    (2, TType.I64, 'from_date', None, None, ), # 2
6105 
    (3, TType.I64, 'to_date', None, None, ), # 3
6106 
    (4, TType.I32, 'status', None, None, ), # 4
6107 
  )
6108 
 
6109 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6110 
    self.customerId = customerId
6111 
    self.from_date = from_date
6112 
    self.to_date = to_date
6113 
    self.status = status
6114 
 
6115 
  def read(self, iprot):
6116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6118 
      return
6119 
    iprot.readStructBegin()
6120 
    while True:
6121 
      (fname, ftype, fid) = iprot.readFieldBegin()
6122 
      if ftype == TType.STOP:
6123 
        break
6124 
      if fid == 1:
6125 
        if ftype == TType.I64:
6126 
          self.customerId = iprot.readI64();
6127 
        else:
6128 
          iprot.skip(ftype)
6129 
      elif fid == 2:
6130 
        if ftype == TType.I64:
6131 
          self.from_date = iprot.readI64();
6132 
        else:
6133 
          iprot.skip(ftype)
6134 
      elif fid == 3:
6135 
        if ftype == TType.I64:
6136 
          self.to_date = iprot.readI64();
6137 
        else:
6138 
          iprot.skip(ftype)
6139 
      elif fid == 4:
6140 
        if ftype == TType.I32:
6141 
          self.status = iprot.readI32();
6142 
        else:
6143 
          iprot.skip(ftype)
6144 
      else:
6145 
        iprot.skip(ftype)
6146 
      iprot.readFieldEnd()
6147 
    iprot.readStructEnd()
6148 
 
6149 
  def write(self, oprot):
6150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6152 
      return
6153 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6154 
    if self.customerId is not None:
94 ashish 6155 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6156 
      oprot.writeI64(self.customerId)
6157 
      oprot.writeFieldEnd()
3431 rajveer 6158 
    if self.from_date is not None:
94 ashish 6159 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6160 
      oprot.writeI64(self.from_date)
6161 
      oprot.writeFieldEnd()
3431 rajveer 6162 
    if self.to_date is not None:
94 ashish 6163 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6164 
      oprot.writeI64(self.to_date)
6165 
      oprot.writeFieldEnd()
3431 rajveer 6166 
    if self.status is not None:
94 ashish 6167 
      oprot.writeFieldBegin('status', TType.I32, 4)
6168 
      oprot.writeI32(self.status)
6169 
      oprot.writeFieldEnd()
6170 
    oprot.writeFieldStop()
6171 
    oprot.writeStructEnd()
6172 
 
3431 rajveer 6173 
  def validate(self):
6174 
    return
6175 
 
6176 
 
94 ashish 6177 
  def __repr__(self):
6178 
    L = ['%s=%r' % (key, value)
6179 
      for key, value in self.__dict__.iteritems()]
6180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6181 
 
6182 
  def __eq__(self, other):
6183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6184 
 
6185 
  def __ne__(self, other):
6186 
    return not (self == other)
6187 
 
6188 
class getTransactionsForCustomer_result:
6189 
  """
6190 
  Attributes:
6191 
   - success
6192 
   - ex
6193 
  """
6194 
 
6195 
  thrift_spec = (
6196 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6198 
  )
6199 
 
6200 
  def __init__(self, success=None, ex=None,):
6201 
    self.success = success
6202 
    self.ex = ex
6203 
 
6204 
  def read(self, iprot):
6205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6207 
      return
6208 
    iprot.readStructBegin()
6209 
    while True:
6210 
      (fname, ftype, fid) = iprot.readFieldBegin()
6211 
      if ftype == TType.STOP:
6212 
        break
6213 
      if fid == 0:
6214 
        if ftype == TType.LIST:
6215 
          self.success = []
685 chandransh 6216 
          (_etype17, _size14) = iprot.readListBegin()
6217 
          for _i18 in xrange(_size14):
6218 
            _elem19 = Transaction()
6219 
            _elem19.read(iprot)
6220 
            self.success.append(_elem19)
94 ashish 6221 
          iprot.readListEnd()
6222 
        else:
6223 
          iprot.skip(ftype)
6224 
      elif fid == 1:
6225 
        if ftype == TType.STRUCT:
6226 
          self.ex = TransactionServiceException()
6227 
          self.ex.read(iprot)
6228 
        else:
6229 
          iprot.skip(ftype)
6230 
      else:
6231 
        iprot.skip(ftype)
6232 
      iprot.readFieldEnd()
6233 
    iprot.readStructEnd()
6234 
 
6235 
  def write(self, oprot):
6236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6238 
      return
6239 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6240 
    if self.success is not None:
94 ashish 6241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6243 
      for iter20 in self.success:
6244 
        iter20.write(oprot)
94 ashish 6245 
      oprot.writeListEnd()
6246 
      oprot.writeFieldEnd()
3431 rajveer 6247 
    if self.ex is not None:
94 ashish 6248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6249 
      self.ex.write(oprot)
6250 
      oprot.writeFieldEnd()
6251 
    oprot.writeFieldStop()
6252 
    oprot.writeStructEnd()
6253 
 
3431 rajveer 6254 
  def validate(self):
6255 
    return
6256 
 
6257 
 
94 ashish 6258 
  def __repr__(self):
6259 
    L = ['%s=%r' % (key, value)
6260 
      for key, value in self.__dict__.iteritems()]
6261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6262 
 
6263 
  def __eq__(self, other):
6264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6265 
 
6266 
  def __ne__(self, other):
6267 
    return not (self == other)
6268 
 
132 ashish 6269 
class getTransactionsForShoppingCartId_args:
6270 
  """
6271 
  Attributes:
6272 
   - shoppingCartId
6273 
  """
6274 
 
6275 
  thrift_spec = (
6276 
    None, # 0
6277 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6278 
  )
6279 
 
6280 
  def __init__(self, shoppingCartId=None,):
6281 
    self.shoppingCartId = shoppingCartId
6282 
 
6283 
  def read(self, iprot):
6284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6286 
      return
6287 
    iprot.readStructBegin()
6288 
    while True:
6289 
      (fname, ftype, fid) = iprot.readFieldBegin()
6290 
      if ftype == TType.STOP:
6291 
        break
6292 
      if fid == 1:
6293 
        if ftype == TType.I64:
6294 
          self.shoppingCartId = iprot.readI64();
6295 
        else:
6296 
          iprot.skip(ftype)
6297 
      else:
6298 
        iprot.skip(ftype)
6299 
      iprot.readFieldEnd()
6300 
    iprot.readStructEnd()
6301 
 
6302 
  def write(self, oprot):
6303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6305 
      return
6306 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6307 
    if self.shoppingCartId is not None:
132 ashish 6308 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6309 
      oprot.writeI64(self.shoppingCartId)
6310 
      oprot.writeFieldEnd()
6311 
    oprot.writeFieldStop()
6312 
    oprot.writeStructEnd()
6313 
 
3431 rajveer 6314 
  def validate(self):
6315 
    return
6316 
 
6317 
 
132 ashish 6318 
  def __repr__(self):
6319 
    L = ['%s=%r' % (key, value)
6320 
      for key, value in self.__dict__.iteritems()]
6321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6322 
 
6323 
  def __eq__(self, other):
6324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6325 
 
6326 
  def __ne__(self, other):
6327 
    return not (self == other)
6328 
 
6329 
class getTransactionsForShoppingCartId_result:
6330 
  """
6331 
  Attributes:
6332 
   - success
6333 
   - ex
6334 
  """
6335 
 
6336 
  thrift_spec = (
6337 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6339 
  )
6340 
 
6341 
  def __init__(self, success=None, ex=None,):
6342 
    self.success = success
6343 
    self.ex = ex
6344 
 
6345 
  def read(self, iprot):
6346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6348 
      return
6349 
    iprot.readStructBegin()
6350 
    while True:
6351 
      (fname, ftype, fid) = iprot.readFieldBegin()
6352 
      if ftype == TType.STOP:
6353 
        break
6354 
      if fid == 0:
6355 
        if ftype == TType.LIST:
6356 
          self.success = []
685 chandransh 6357 
          (_etype24, _size21) = iprot.readListBegin()
6358 
          for _i25 in xrange(_size21):
6359 
            _elem26 = Transaction()
6360 
            _elem26.read(iprot)
6361 
            self.success.append(_elem26)
132 ashish 6362 
          iprot.readListEnd()
6363 
        else:
6364 
          iprot.skip(ftype)
6365 
      elif fid == 1:
6366 
        if ftype == TType.STRUCT:
6367 
          self.ex = TransactionServiceException()
6368 
          self.ex.read(iprot)
6369 
        else:
6370 
          iprot.skip(ftype)
6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
6380 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6381 
    if self.success is not None:
132 ashish 6382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6384 
      for iter27 in self.success:
6385 
        iter27.write(oprot)
132 ashish 6386 
      oprot.writeListEnd()
6387 
      oprot.writeFieldEnd()
3431 rajveer 6388 
    if self.ex is not None:
132 ashish 6389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6390 
      self.ex.write(oprot)
6391 
      oprot.writeFieldEnd()
6392 
    oprot.writeFieldStop()
6393 
    oprot.writeStructEnd()
6394 
 
3431 rajveer 6395 
  def validate(self):
6396 
    return
6397 
 
6398 
 
132 ashish 6399 
  def __repr__(self):
6400 
    L = ['%s=%r' % (key, value)
6401 
      for key, value in self.__dict__.iteritems()]
6402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6403 
 
6404 
  def __eq__(self, other):
6405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6406 
 
6407 
  def __ne__(self, other):
6408 
    return not (self == other)
6409 
 
94 ashish 6410 
class getTransactionStatus_args:
6411 
  """
6412 
  Attributes:
6413 
   - transactionId
6414 
  """
6415 
 
6416 
  thrift_spec = (
6417 
    None, # 0
6418 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6419 
  )
6420 
 
6421 
  def __init__(self, transactionId=None,):
6422 
    self.transactionId = transactionId
6423 
 
6424 
  def read(self, iprot):
6425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6427 
      return
6428 
    iprot.readStructBegin()
6429 
    while True:
6430 
      (fname, ftype, fid) = iprot.readFieldBegin()
6431 
      if ftype == TType.STOP:
6432 
        break
6433 
      if fid == 1:
6434 
        if ftype == TType.I64:
6435 
          self.transactionId = iprot.readI64();
6436 
        else:
6437 
          iprot.skip(ftype)
6438 
      else:
6439 
        iprot.skip(ftype)
6440 
      iprot.readFieldEnd()
6441 
    iprot.readStructEnd()
6442 
 
6443 
  def write(self, oprot):
6444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6446 
      return
6447 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6448 
    if self.transactionId is not None:
94 ashish 6449 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6450 
      oprot.writeI64(self.transactionId)
6451 
      oprot.writeFieldEnd()
6452 
    oprot.writeFieldStop()
6453 
    oprot.writeStructEnd()
6454 
 
3431 rajveer 6455 
  def validate(self):
6456 
    return
6457 
 
6458 
 
94 ashish 6459 
  def __repr__(self):
6460 
    L = ['%s=%r' % (key, value)
6461 
      for key, value in self.__dict__.iteritems()]
6462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6463 
 
6464 
  def __eq__(self, other):
6465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6466 
 
6467 
  def __ne__(self, other):
6468 
    return not (self == other)
6469 
 
6470 
class getTransactionStatus_result:
6471 
  """
6472 
  Attributes:
6473 
   - success
6474 
   - ex
6475 
  """
6476 
 
6477 
  thrift_spec = (
6478 
    (0, TType.I32, 'success', None, None, ), # 0
6479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6480 
  )
6481 
 
6482 
  def __init__(self, success=None, ex=None,):
6483 
    self.success = success
6484 
    self.ex = ex
6485 
 
6486 
  def read(self, iprot):
6487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6489 
      return
6490 
    iprot.readStructBegin()
6491 
    while True:
6492 
      (fname, ftype, fid) = iprot.readFieldBegin()
6493 
      if ftype == TType.STOP:
6494 
        break
6495 
      if fid == 0:
6496 
        if ftype == TType.I32:
6497 
          self.success = iprot.readI32();
6498 
        else:
6499 
          iprot.skip(ftype)
6500 
      elif fid == 1:
6501 
        if ftype == TType.STRUCT:
6502 
          self.ex = TransactionServiceException()
6503 
          self.ex.read(iprot)
6504 
        else:
6505 
          iprot.skip(ftype)
6506 
      else:
6507 
        iprot.skip(ftype)
6508 
      iprot.readFieldEnd()
6509 
    iprot.readStructEnd()
6510 
 
6511 
  def write(self, oprot):
6512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6514 
      return
6515 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6516 
    if self.success is not None:
94 ashish 6517 
      oprot.writeFieldBegin('success', TType.I32, 0)
6518 
      oprot.writeI32(self.success)
6519 
      oprot.writeFieldEnd()
3431 rajveer 6520 
    if self.ex is not None:
94 ashish 6521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6522 
      self.ex.write(oprot)
6523 
      oprot.writeFieldEnd()
6524 
    oprot.writeFieldStop()
6525 
    oprot.writeStructEnd()
6526 
 
3431 rajveer 6527 
  def validate(self):
6528 
    return
6529 
 
6530 
 
94 ashish 6531 
  def __repr__(self):
6532 
    L = ['%s=%r' % (key, value)
6533 
      for key, value in self.__dict__.iteritems()]
6534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6535 
 
6536 
  def __eq__(self, other):
6537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6538 
 
6539 
  def __ne__(self, other):
6540 
    return not (self == other)
6541 
 
6542 
class changeTransactionStatus_args:
6543 
  """
6544 
  Attributes:
6545 
   - transactionId
6546 
   - status
6547 
   - description
6548 
  """
6549 
 
6550 
  thrift_spec = (
6551 
    None, # 0
6552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6553 
    (2, TType.I32, 'status', None, None, ), # 2
6554 
    (3, TType.STRING, 'description', None, None, ), # 3
6555 
  )
6556 
 
6557 
  def __init__(self, transactionId=None, status=None, description=None,):
6558 
    self.transactionId = transactionId
6559 
    self.status = status
6560 
    self.description = description
6561 
 
6562 
  def read(self, iprot):
6563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6565 
      return
6566 
    iprot.readStructBegin()
6567 
    while True:
6568 
      (fname, ftype, fid) = iprot.readFieldBegin()
6569 
      if ftype == TType.STOP:
6570 
        break
6571 
      if fid == 1:
6572 
        if ftype == TType.I64:
6573 
          self.transactionId = iprot.readI64();
6574 
        else:
6575 
          iprot.skip(ftype)
6576 
      elif fid == 2:
6577 
        if ftype == TType.I32:
6578 
          self.status = iprot.readI32();
6579 
        else:
6580 
          iprot.skip(ftype)
6581 
      elif fid == 3:
6582 
        if ftype == TType.STRING:
6583 
          self.description = iprot.readString();
6584 
        else:
6585 
          iprot.skip(ftype)
6586 
      else:
6587 
        iprot.skip(ftype)
6588 
      iprot.readFieldEnd()
6589 
    iprot.readStructEnd()
6590 
 
6591 
  def write(self, oprot):
6592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6594 
      return
6595 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6596 
    if self.transactionId is not None:
94 ashish 6597 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6598 
      oprot.writeI64(self.transactionId)
6599 
      oprot.writeFieldEnd()
3431 rajveer 6600 
    if self.status is not None:
94 ashish 6601 
      oprot.writeFieldBegin('status', TType.I32, 2)
6602 
      oprot.writeI32(self.status)
6603 
      oprot.writeFieldEnd()
3431 rajveer 6604 
    if self.description is not None:
94 ashish 6605 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6606 
      oprot.writeString(self.description)
6607 
      oprot.writeFieldEnd()
6608 
    oprot.writeFieldStop()
6609 
    oprot.writeStructEnd()
6610 
 
3431 rajveer 6611 
  def validate(self):
6612 
    return
6613 
 
6614 
 
94 ashish 6615 
  def __repr__(self):
6616 
    L = ['%s=%r' % (key, value)
6617 
      for key, value in self.__dict__.iteritems()]
6618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6619 
 
6620 
  def __eq__(self, other):
6621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6622 
 
6623 
  def __ne__(self, other):
6624 
    return not (self == other)
6625 
 
6626 
class changeTransactionStatus_result:
6627 
  """
6628 
  Attributes:
6629 
   - success
6630 
   - ex
6631 
  """
6632 
 
6633 
  thrift_spec = (
6634 
    (0, TType.BOOL, 'success', None, None, ), # 0
6635 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6636 
  )
6637 
 
6638 
  def __init__(self, success=None, ex=None,):
6639 
    self.success = success
6640 
    self.ex = ex
6641 
 
6642 
  def read(self, iprot):
6643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6645 
      return
6646 
    iprot.readStructBegin()
6647 
    while True:
6648 
      (fname, ftype, fid) = iprot.readFieldBegin()
6649 
      if ftype == TType.STOP:
6650 
        break
6651 
      if fid == 0:
6652 
        if ftype == TType.BOOL:
6653 
          self.success = iprot.readBool();
6654 
        else:
6655 
          iprot.skip(ftype)
6656 
      elif fid == 1:
6657 
        if ftype == TType.STRUCT:
6658 
          self.ex = TransactionServiceException()
6659 
          self.ex.read(iprot)
6660 
        else:
6661 
          iprot.skip(ftype)
6662 
      else:
6663 
        iprot.skip(ftype)
6664 
      iprot.readFieldEnd()
6665 
    iprot.readStructEnd()
6666 
 
6667 
  def write(self, oprot):
6668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6670 
      return
6671 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6672 
    if self.success is not None:
94 ashish 6673 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6674 
      oprot.writeBool(self.success)
6675 
      oprot.writeFieldEnd()
3431 rajveer 6676 
    if self.ex is not None:
94 ashish 6677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6678 
      self.ex.write(oprot)
6679 
      oprot.writeFieldEnd()
6680 
    oprot.writeFieldStop()
6681 
    oprot.writeStructEnd()
6682 
 
3431 rajveer 6683 
  def validate(self):
6684 
    return
6685 
 
6686 
 
94 ashish 6687 
  def __repr__(self):
6688 
    L = ['%s=%r' % (key, value)
6689 
      for key, value in self.__dict__.iteritems()]
6690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6691 
 
6692 
  def __eq__(self, other):
6693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6694 
 
6695 
  def __ne__(self, other):
6696 
    return not (self == other)
6697 
 
1398 varun.gupt 6698 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6699 
  """
6700 
  Attributes:
6701 
   - transactionId
6702 
  """
6703 
 
6704 
  thrift_spec = (
6705 
    None, # 0
6706 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6707 
  )
6708 
 
6709 
  def __init__(self, transactionId=None,):
6710 
    self.transactionId = transactionId
6711 
 
6712 
  def read(self, iprot):
6713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6715 
      return
6716 
    iprot.readStructBegin()
6717 
    while True:
6718 
      (fname, ftype, fid) = iprot.readFieldBegin()
6719 
      if ftype == TType.STOP:
6720 
        break
6721 
      if fid == 1:
6722 
        if ftype == TType.I64:
6723 
          self.transactionId = iprot.readI64();
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      else:
6727 
        iprot.skip(ftype)
6728 
      iprot.readFieldEnd()
6729 
    iprot.readStructEnd()
6730 
 
6731 
  def write(self, oprot):
6732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6734 
      return
1398 varun.gupt 6735 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6736 
    if self.transactionId is not None:
1382 varun.gupt 6737 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6738 
      oprot.writeI64(self.transactionId)
6739 
      oprot.writeFieldEnd()
6740 
    oprot.writeFieldStop()
6741 
    oprot.writeStructEnd()
6742 
 
3431 rajveer 6743 
  def validate(self):
6744 
    return
6745 
 
6746 
 
1382 varun.gupt 6747 
  def __repr__(self):
6748 
    L = ['%s=%r' % (key, value)
6749 
      for key, value in self.__dict__.iteritems()]
6750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6751 
 
6752 
  def __eq__(self, other):
6753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6754 
 
6755 
  def __ne__(self, other):
6756 
    return not (self == other)
6757 
 
1398 varun.gupt 6758 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6759 
  """
6760 
  Attributes:
6761 
   - success
6762 
   - ex
6763 
  """
6764 
 
6765 
  thrift_spec = (
6766 
    (0, TType.BOOL, 'success', None, None, ), # 0
6767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6768 
  )
6769 
 
6770 
  def __init__(self, success=None, ex=None,):
6771 
    self.success = success
6772 
    self.ex = ex
6773 
 
6774 
  def read(self, iprot):
6775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6777 
      return
6778 
    iprot.readStructBegin()
6779 
    while True:
6780 
      (fname, ftype, fid) = iprot.readFieldBegin()
6781 
      if ftype == TType.STOP:
6782 
        break
6783 
      if fid == 0:
6784 
        if ftype == TType.BOOL:
6785 
          self.success = iprot.readBool();
6786 
        else:
6787 
          iprot.skip(ftype)
6788 
      elif fid == 1:
6789 
        if ftype == TType.STRUCT:
6790 
          self.ex = TransactionServiceException()
6791 
          self.ex.read(iprot)
6792 
        else:
6793 
          iprot.skip(ftype)
6794 
      else:
6795 
        iprot.skip(ftype)
6796 
      iprot.readFieldEnd()
6797 
    iprot.readStructEnd()
6798 
 
6799 
  def write(self, oprot):
6800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6802 
      return
1398 varun.gupt 6803 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6804 
    if self.success is not None:
1382 varun.gupt 6805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6806 
      oprot.writeBool(self.success)
6807 
      oprot.writeFieldEnd()
3431 rajveer 6808 
    if self.ex is not None:
1382 varun.gupt 6809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6810 
      self.ex.write(oprot)
6811 
      oprot.writeFieldEnd()
6812 
    oprot.writeFieldStop()
6813 
    oprot.writeStructEnd()
6814 
 
3431 rajveer 6815 
  def validate(self):
6816 
    return
6817 
 
6818 
 
1382 varun.gupt 6819 
  def __repr__(self):
6820 
    L = ['%s=%r' % (key, value)
6821 
      for key, value in self.__dict__.iteritems()]
6822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6823 
 
6824 
  def __eq__(self, other):
6825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6826 
 
6827 
  def __ne__(self, other):
6828 
    return not (self == other)
6829 
 
483 rajveer 6830 
class getAllOrders_args:
94 ashish 6831 
  """
6832 
  Attributes:
483 rajveer 6833 
   - status
6834 
   - from_date
6835 
   - to_date
6836 
   - warehouse_id
94 ashish 6837 
  """
6838 
 
6839 
  thrift_spec = (
6840 
    None, # 0
483 rajveer 6841 
    (1, TType.I32, 'status', None, None, ), # 1
6842 
    (2, TType.I64, 'from_date', None, None, ), # 2
6843 
    (3, TType.I64, 'to_date', None, None, ), # 3
6844 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6845 
  )
6846 
 
483 rajveer 6847 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6848 
    self.status = status
6849 
    self.from_date = from_date
6850 
    self.to_date = to_date
6851 
    self.warehouse_id = warehouse_id
94 ashish 6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 1:
483 rajveer 6863 
        if ftype == TType.I32:
6864 
          self.status = iprot.readI32();
94 ashish 6865 
        else:
6866 
          iprot.skip(ftype)
483 rajveer 6867 
      elif fid == 2:
6868 
        if ftype == TType.I64:
6869 
          self.from_date = iprot.readI64();
94 ashish 6870 
        else:
6871 
          iprot.skip(ftype)
483 rajveer 6872 
      elif fid == 3:
6873 
        if ftype == TType.I64:
6874 
          self.to_date = iprot.readI64();
94 ashish 6875 
        else:
6876 
          iprot.skip(ftype)
483 rajveer 6877 
      elif fid == 4:
94 ashish 6878 
        if ftype == TType.I64:
483 rajveer 6879 
          self.warehouse_id = iprot.readI64();
94 ashish 6880 
        else:
6881 
          iprot.skip(ftype)
6882 
      else:
6883 
        iprot.skip(ftype)
6884 
      iprot.readFieldEnd()
6885 
    iprot.readStructEnd()
6886 
 
6887 
  def write(self, oprot):
6888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6890 
      return
483 rajveer 6891 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6892 
    if self.status is not None:
483 rajveer 6893 
      oprot.writeFieldBegin('status', TType.I32, 1)
6894 
      oprot.writeI32(self.status)
94 ashish 6895 
      oprot.writeFieldEnd()
3431 rajveer 6896 
    if self.from_date is not None:
483 rajveer 6897 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6898 
      oprot.writeI64(self.from_date)
94 ashish 6899 
      oprot.writeFieldEnd()
3431 rajveer 6900 
    if self.to_date is not None:
483 rajveer 6901 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6902 
      oprot.writeI64(self.to_date)
94 ashish 6903 
      oprot.writeFieldEnd()
3431 rajveer 6904 
    if self.warehouse_id is not None:
483 rajveer 6905 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6906 
      oprot.writeI64(self.warehouse_id)
94 ashish 6907 
      oprot.writeFieldEnd()
6908 
    oprot.writeFieldStop()
6909 
    oprot.writeStructEnd()
6910 
 
3431 rajveer 6911 
  def validate(self):
6912 
    return
6913 
 
6914 
 
94 ashish 6915 
  def __repr__(self):
6916 
    L = ['%s=%r' % (key, value)
6917 
      for key, value in self.__dict__.iteritems()]
6918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6919 
 
6920 
  def __eq__(self, other):
6921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6922 
 
6923 
  def __ne__(self, other):
6924 
    return not (self == other)
6925 
 
483 rajveer 6926 
class getAllOrders_result:
94 ashish 6927 
  """
6928 
  Attributes:
6929 
   - success
6930 
   - ex
6931 
  """
6932 
 
6933 
  thrift_spec = (
483 rajveer 6934 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6936 
  )
6937 
 
6938 
  def __init__(self, success=None, ex=None,):
6939 
    self.success = success
6940 
    self.ex = ex
6941 
 
6942 
  def read(self, iprot):
6943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6945 
      return
6946 
    iprot.readStructBegin()
6947 
    while True:
6948 
      (fname, ftype, fid) = iprot.readFieldBegin()
6949 
      if ftype == TType.STOP:
6950 
        break
6951 
      if fid == 0:
483 rajveer 6952 
        if ftype == TType.LIST:
6953 
          self.success = []
685 chandransh 6954 
          (_etype31, _size28) = iprot.readListBegin()
6955 
          for _i32 in xrange(_size28):
6956 
            _elem33 = Order()
6957 
            _elem33.read(iprot)
6958 
            self.success.append(_elem33)
483 rajveer 6959 
          iprot.readListEnd()
94 ashish 6960 
        else:
6961 
          iprot.skip(ftype)
6962 
      elif fid == 1:
6963 
        if ftype == TType.STRUCT:
6964 
          self.ex = TransactionServiceException()
6965 
          self.ex.read(iprot)
6966 
        else:
6967 
          iprot.skip(ftype)
6968 
      else:
6969 
        iprot.skip(ftype)
6970 
      iprot.readFieldEnd()
6971 
    iprot.readStructEnd()
6972 
 
6973 
  def write(self, oprot):
6974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6976 
      return
483 rajveer 6977 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6978 
    if self.success is not None:
483 rajveer 6979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6981 
      for iter34 in self.success:
6982 
        iter34.write(oprot)
483 rajveer 6983 
      oprot.writeListEnd()
94 ashish 6984 
      oprot.writeFieldEnd()
3431 rajveer 6985 
    if self.ex is not None:
94 ashish 6986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6987 
      self.ex.write(oprot)
6988 
      oprot.writeFieldEnd()
6989 
    oprot.writeFieldStop()
6990 
    oprot.writeStructEnd()
6991 
 
3431 rajveer 6992 
  def validate(self):
6993 
    return
6994 
 
6995 
 
94 ashish 6996 
  def __repr__(self):
6997 
    L = ['%s=%r' % (key, value)
6998 
      for key, value in self.__dict__.iteritems()]
6999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7000 
 
7001 
  def __eq__(self, other):
7002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7003 
 
7004 
  def __ne__(self, other):
7005 
    return not (self == other)
7006 
 
4133 chandransh 7007 
class getOrdersInBatch_args:
7008 
  """
7009 
  Attributes:
7010 
   - statuses
7011 
   - offset
7012 
   - limit
7013 
   - warehouse_id
7014 
  """
7015 
 
7016 
  thrift_spec = (
7017 
    None, # 0
7018 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7019 
    (2, TType.I64, 'offset', None, None, ), # 2
7020 
    (3, TType.I64, 'limit', None, None, ), # 3
7021 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7022 
  )
7023 
 
7024 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7025 
    self.statuses = statuses
7026 
    self.offset = offset
7027 
    self.limit = limit
7028 
    self.warehouse_id = warehouse_id
7029 
 
7030 
  def read(self, iprot):
7031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7033 
      return
7034 
    iprot.readStructBegin()
7035 
    while True:
7036 
      (fname, ftype, fid) = iprot.readFieldBegin()
7037 
      if ftype == TType.STOP:
7038 
        break
7039 
      if fid == 1:
7040 
        if ftype == TType.LIST:
7041 
          self.statuses = []
7042 
          (_etype38, _size35) = iprot.readListBegin()
7043 
          for _i39 in xrange(_size35):
7044 
            _elem40 = iprot.readI32();
7045 
            self.statuses.append(_elem40)
7046 
          iprot.readListEnd()
7047 
        else:
7048 
          iprot.skip(ftype)
7049 
      elif fid == 2:
7050 
        if ftype == TType.I64:
7051 
          self.offset = iprot.readI64();
7052 
        else:
7053 
          iprot.skip(ftype)
7054 
      elif fid == 3:
7055 
        if ftype == TType.I64:
7056 
          self.limit = iprot.readI64();
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      elif fid == 4:
7060 
        if ftype == TType.I64:
7061 
          self.warehouse_id = iprot.readI64();
7062 
        else:
7063 
          iprot.skip(ftype)
7064 
      else:
7065 
        iprot.skip(ftype)
7066 
      iprot.readFieldEnd()
7067 
    iprot.readStructEnd()
7068 
 
7069 
  def write(self, oprot):
7070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7072 
      return
7073 
    oprot.writeStructBegin('getOrdersInBatch_args')
7074 
    if self.statuses is not None:
7075 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7076 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7077 
      for iter41 in self.statuses:
7078 
        oprot.writeI32(iter41)
7079 
      oprot.writeListEnd()
7080 
      oprot.writeFieldEnd()
7081 
    if self.offset is not None:
7082 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7083 
      oprot.writeI64(self.offset)
7084 
      oprot.writeFieldEnd()
7085 
    if self.limit is not None:
7086 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7087 
      oprot.writeI64(self.limit)
7088 
      oprot.writeFieldEnd()
7089 
    if self.warehouse_id is not None:
7090 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7091 
      oprot.writeI64(self.warehouse_id)
7092 
      oprot.writeFieldEnd()
7093 
    oprot.writeFieldStop()
7094 
    oprot.writeStructEnd()
7095 
 
7096 
  def validate(self):
7097 
    return
7098 
 
7099 
 
7100 
  def __repr__(self):
7101 
    L = ['%s=%r' % (key, value)
7102 
      for key, value in self.__dict__.iteritems()]
7103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7104 
 
7105 
  def __eq__(self, other):
7106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7107 
 
7108 
  def __ne__(self, other):
7109 
    return not (self == other)
7110 
 
7111 
class getOrdersInBatch_result:
7112 
  """
7113 
  Attributes:
7114 
   - success
7115 
   - ex
7116 
  """
7117 
 
7118 
  thrift_spec = (
7119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7121 
  )
7122 
 
7123 
  def __init__(self, success=None, ex=None,):
7124 
    self.success = success
7125 
    self.ex = ex
7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 0:
7137 
        if ftype == TType.LIST:
7138 
          self.success = []
7139 
          (_etype45, _size42) = iprot.readListBegin()
7140 
          for _i46 in xrange(_size42):
7141 
            _elem47 = Order()
7142 
            _elem47.read(iprot)
7143 
            self.success.append(_elem47)
7144 
          iprot.readListEnd()
7145 
        else:
7146 
          iprot.skip(ftype)
7147 
      elif fid == 1:
7148 
        if ftype == TType.STRUCT:
7149 
          self.ex = TransactionServiceException()
7150 
          self.ex.read(iprot)
7151 
        else:
7152 
          iprot.skip(ftype)
7153 
      else:
7154 
        iprot.skip(ftype)
7155 
      iprot.readFieldEnd()
7156 
    iprot.readStructEnd()
7157 
 
7158 
  def write(self, oprot):
7159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7161 
      return
7162 
    oprot.writeStructBegin('getOrdersInBatch_result')
7163 
    if self.success is not None:
7164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7166 
      for iter48 in self.success:
7167 
        iter48.write(oprot)
7168 
      oprot.writeListEnd()
7169 
      oprot.writeFieldEnd()
7170 
    if self.ex is not None:
7171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7172 
      self.ex.write(oprot)
7173 
      oprot.writeFieldEnd()
7174 
    oprot.writeFieldStop()
7175 
    oprot.writeStructEnd()
7176 
 
7177 
  def validate(self):
7178 
    return
7179 
 
7180 
 
7181 
  def __repr__(self):
7182 
    L = ['%s=%r' % (key, value)
7183 
      for key, value in self.__dict__.iteritems()]
7184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7185 
 
7186 
  def __eq__(self, other):
7187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7188 
 
7189 
  def __ne__(self, other):
7190 
    return not (self == other)
7191 
 
7192 
class getOrderCount_args:
7193 
  """
7194 
  Attributes:
7195 
   - statuses
7196 
   - warehouseId
7197 
  """
7198 
 
7199 
  thrift_spec = (
7200 
    None, # 0
7201 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7202 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7203 
  )
7204 
 
7205 
  def __init__(self, statuses=None, warehouseId=None,):
7206 
    self.statuses = statuses
7207 
    self.warehouseId = warehouseId
7208 
 
7209 
  def read(self, iprot):
7210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7212 
      return
7213 
    iprot.readStructBegin()
7214 
    while True:
7215 
      (fname, ftype, fid) = iprot.readFieldBegin()
7216 
      if ftype == TType.STOP:
7217 
        break
7218 
      if fid == 1:
7219 
        if ftype == TType.LIST:
7220 
          self.statuses = []
7221 
          (_etype52, _size49) = iprot.readListBegin()
7222 
          for _i53 in xrange(_size49):
7223 
            _elem54 = iprot.readI32();
7224 
            self.statuses.append(_elem54)
7225 
          iprot.readListEnd()
7226 
        else:
7227 
          iprot.skip(ftype)
7228 
      elif fid == 2:
7229 
        if ftype == TType.I64:
7230 
          self.warehouseId = iprot.readI64();
7231 
        else:
7232 
          iprot.skip(ftype)
7233 
      else:
7234 
        iprot.skip(ftype)
7235 
      iprot.readFieldEnd()
7236 
    iprot.readStructEnd()
7237 
 
7238 
  def write(self, oprot):
7239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7241 
      return
7242 
    oprot.writeStructBegin('getOrderCount_args')
7243 
    if self.statuses is not None:
7244 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7245 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7246 
      for iter55 in self.statuses:
7247 
        oprot.writeI32(iter55)
7248 
      oprot.writeListEnd()
7249 
      oprot.writeFieldEnd()
7250 
    if self.warehouseId is not None:
7251 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7252 
      oprot.writeI64(self.warehouseId)
7253 
      oprot.writeFieldEnd()
7254 
    oprot.writeFieldStop()
7255 
    oprot.writeStructEnd()
7256 
 
7257 
  def validate(self):
7258 
    return
7259 
 
7260 
 
7261 
  def __repr__(self):
7262 
    L = ['%s=%r' % (key, value)
7263 
      for key, value in self.__dict__.iteritems()]
7264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7265 
 
7266 
  def __eq__(self, other):
7267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7268 
 
7269 
  def __ne__(self, other):
7270 
    return not (self == other)
7271 
 
7272 
class getOrderCount_result:
7273 
  """
7274 
  Attributes:
7275 
   - success
7276 
   - ex
7277 
  """
7278 
 
7279 
  thrift_spec = (
7280 
    (0, TType.I32, 'success', None, None, ), # 0
7281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7282 
  )
7283 
 
7284 
  def __init__(self, success=None, ex=None,):
7285 
    self.success = success
7286 
    self.ex = ex
7287 
 
7288 
  def read(self, iprot):
7289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7291 
      return
7292 
    iprot.readStructBegin()
7293 
    while True:
7294 
      (fname, ftype, fid) = iprot.readFieldBegin()
7295 
      if ftype == TType.STOP:
7296 
        break
7297 
      if fid == 0:
7298 
        if ftype == TType.I32:
7299 
          self.success = iprot.readI32();
7300 
        else:
7301 
          iprot.skip(ftype)
7302 
      elif fid == 1:
7303 
        if ftype == TType.STRUCT:
7304 
          self.ex = TransactionServiceException()
7305 
          self.ex.read(iprot)
7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      else:
7309 
        iprot.skip(ftype)
7310 
      iprot.readFieldEnd()
7311 
    iprot.readStructEnd()
7312 
 
7313 
  def write(self, oprot):
7314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7316 
      return
7317 
    oprot.writeStructBegin('getOrderCount_result')
7318 
    if self.success is not None:
7319 
      oprot.writeFieldBegin('success', TType.I32, 0)
7320 
      oprot.writeI32(self.success)
7321 
      oprot.writeFieldEnd()
7322 
    if self.ex is not None:
7323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7324 
      self.ex.write(oprot)
7325 
      oprot.writeFieldEnd()
7326 
    oprot.writeFieldStop()
7327 
    oprot.writeStructEnd()
7328 
 
7329 
  def validate(self):
7330 
    return
7331 
 
7332 
 
7333 
  def __repr__(self):
7334 
    L = ['%s=%r' % (key, value)
7335 
      for key, value in self.__dict__.iteritems()]
7336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7337 
 
7338 
  def __eq__(self, other):
7339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7340 
 
7341 
  def __ne__(self, other):
7342 
    return not (self == other)
7343 
 
999 varun.gupt 7344 
class getOrdersByBillingDate_args:
7345 
  """
7346 
  Attributes:
7347 
   - status
7348 
   - start_billing_date
7349 
   - end_billing_date
7350 
   - warehouse_id
7351 
  """
7352 
 
7353 
  thrift_spec = (
7354 
    None, # 0
7355 
    (1, TType.I32, 'status', None, None, ), # 1
7356 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7357 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7358 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7359 
  )
7360 
 
7361 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7362 
    self.status = status
7363 
    self.start_billing_date = start_billing_date
7364 
    self.end_billing_date = end_billing_date
7365 
    self.warehouse_id = warehouse_id
7366 
 
7367 
  def read(self, iprot):
7368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7370 
      return
7371 
    iprot.readStructBegin()
7372 
    while True:
7373 
      (fname, ftype, fid) = iprot.readFieldBegin()
7374 
      if ftype == TType.STOP:
7375 
        break
7376 
      if fid == 1:
7377 
        if ftype == TType.I32:
7378 
          self.status = iprot.readI32();
7379 
        else:
7380 
          iprot.skip(ftype)
7381 
      elif fid == 2:
7382 
        if ftype == TType.I64:
7383 
          self.start_billing_date = iprot.readI64();
7384 
        else:
7385 
          iprot.skip(ftype)
7386 
      elif fid == 3:
7387 
        if ftype == TType.I64:
7388 
          self.end_billing_date = iprot.readI64();
7389 
        else:
7390 
          iprot.skip(ftype)
7391 
      elif fid == 4:
7392 
        if ftype == TType.I64:
7393 
          self.warehouse_id = iprot.readI64();
7394 
        else:
7395 
          iprot.skip(ftype)
7396 
      else:
7397 
        iprot.skip(ftype)
7398 
      iprot.readFieldEnd()
7399 
    iprot.readStructEnd()
7400 
 
7401 
  def write(self, oprot):
7402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7404 
      return
7405 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7406 
    if self.status is not None:
999 varun.gupt 7407 
      oprot.writeFieldBegin('status', TType.I32, 1)
7408 
      oprot.writeI32(self.status)
7409 
      oprot.writeFieldEnd()
3431 rajveer 7410 
    if self.start_billing_date is not None:
999 varun.gupt 7411 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7412 
      oprot.writeI64(self.start_billing_date)
7413 
      oprot.writeFieldEnd()
3431 rajveer 7414 
    if self.end_billing_date is not None:
999 varun.gupt 7415 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7416 
      oprot.writeI64(self.end_billing_date)
7417 
      oprot.writeFieldEnd()
3431 rajveer 7418 
    if self.warehouse_id is not None:
999 varun.gupt 7419 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7420 
      oprot.writeI64(self.warehouse_id)
7421 
      oprot.writeFieldEnd()
7422 
    oprot.writeFieldStop()
7423 
    oprot.writeStructEnd()
7424 
 
3431 rajveer 7425 
  def validate(self):
7426 
    return
7427 
 
7428 
 
999 varun.gupt 7429 
  def __repr__(self):
7430 
    L = ['%s=%r' % (key, value)
7431 
      for key, value in self.__dict__.iteritems()]
7432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7433 
 
7434 
  def __eq__(self, other):
7435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7436 
 
7437 
  def __ne__(self, other):
7438 
    return not (self == other)
7439 
 
7440 
class getOrdersByBillingDate_result:
7441 
  """
7442 
  Attributes:
7443 
   - success
7444 
   - ex
7445 
  """
7446 
 
7447 
  thrift_spec = (
7448 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7450 
  )
7451 
 
7452 
  def __init__(self, success=None, ex=None,):
7453 
    self.success = success
7454 
    self.ex = ex
7455 
 
7456 
  def read(self, iprot):
7457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7459 
      return
7460 
    iprot.readStructBegin()
7461 
    while True:
7462 
      (fname, ftype, fid) = iprot.readFieldBegin()
7463 
      if ftype == TType.STOP:
7464 
        break
7465 
      if fid == 0:
7466 
        if ftype == TType.LIST:
7467 
          self.success = []
4133 chandransh 7468 
          (_etype59, _size56) = iprot.readListBegin()
7469 
          for _i60 in xrange(_size56):
7470 
            _elem61 = Order()
7471 
            _elem61.read(iprot)
7472 
            self.success.append(_elem61)
999 varun.gupt 7473 
          iprot.readListEnd()
7474 
        else:
7475 
          iprot.skip(ftype)
7476 
      elif fid == 1:
7477 
        if ftype == TType.STRUCT:
7478 
          self.ex = TransactionServiceException()
7479 
          self.ex.read(iprot)
7480 
        else:
7481 
          iprot.skip(ftype)
7482 
      else:
7483 
        iprot.skip(ftype)
7484 
      iprot.readFieldEnd()
7485 
    iprot.readStructEnd()
7486 
 
7487 
  def write(self, oprot):
7488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7490 
      return
7491 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7492 
    if self.success is not None:
999 varun.gupt 7493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7495 
      for iter62 in self.success:
7496 
        iter62.write(oprot)
999 varun.gupt 7497 
      oprot.writeListEnd()
7498 
      oprot.writeFieldEnd()
3431 rajveer 7499 
    if self.ex is not None:
999 varun.gupt 7500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7501 
      self.ex.write(oprot)
7502 
      oprot.writeFieldEnd()
7503 
    oprot.writeFieldStop()
7504 
    oprot.writeStructEnd()
7505 
 
3431 rajveer 7506 
  def validate(self):
7507 
    return
7508 
 
7509 
 
999 varun.gupt 7510 
  def __repr__(self):
7511 
    L = ['%s=%r' % (key, value)
7512 
      for key, value in self.__dict__.iteritems()]
7513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7514 
 
7515 
  def __eq__(self, other):
7516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7517 
 
7518 
  def __ne__(self, other):
7519 
    return not (self == other)
7520 
 
3427 chandransh 7521 
class getOrdersByShippingDate_args:
7522 
  """
7523 
  Attributes:
7524 
   - fromShippingDate
7525 
   - toShippingDate
7526 
   - providerId
7527 
   - warehouseId
3451 chandransh 7528 
   - cod
3427 chandransh 7529 
  """
7530 
 
7531 
  thrift_spec = (
7532 
    None, # 0
7533 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7534 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7535 
    (3, TType.I64, 'providerId', None, None, ), # 3
7536 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7537 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7538 
  )
7539 
 
3451 chandransh 7540 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7541 
    self.fromShippingDate = fromShippingDate
7542 
    self.toShippingDate = toShippingDate
7543 
    self.providerId = providerId
7544 
    self.warehouseId = warehouseId
3451 chandransh 7545 
    self.cod = cod
3427 chandransh 7546 
 
7547 
  def read(self, iprot):
7548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7550 
      return
7551 
    iprot.readStructBegin()
7552 
    while True:
7553 
      (fname, ftype, fid) = iprot.readFieldBegin()
7554 
      if ftype == TType.STOP:
7555 
        break
7556 
      if fid == 1:
7557 
        if ftype == TType.I64:
7558 
          self.fromShippingDate = iprot.readI64();
7559 
        else:
7560 
          iprot.skip(ftype)
7561 
      elif fid == 2:
7562 
        if ftype == TType.I64:
7563 
          self.toShippingDate = iprot.readI64();
7564 
        else:
7565 
          iprot.skip(ftype)
7566 
      elif fid == 3:
7567 
        if ftype == TType.I64:
7568 
          self.providerId = iprot.readI64();
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      elif fid == 4:
7572 
        if ftype == TType.I64:
7573 
          self.warehouseId = iprot.readI64();
7574 
        else:
7575 
          iprot.skip(ftype)
3451 chandransh 7576 
      elif fid == 5:
7577 
        if ftype == TType.BOOL:
7578 
          self.cod = iprot.readBool();
7579 
        else:
7580 
          iprot.skip(ftype)
3427 chandransh 7581 
      else:
7582 
        iprot.skip(ftype)
7583 
      iprot.readFieldEnd()
7584 
    iprot.readStructEnd()
7585 
 
7586 
  def write(self, oprot):
7587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7589 
      return
7590 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7591 
    if self.fromShippingDate is not None:
3427 chandransh 7592 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7593 
      oprot.writeI64(self.fromShippingDate)
7594 
      oprot.writeFieldEnd()
3431 rajveer 7595 
    if self.toShippingDate is not None:
3427 chandransh 7596 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7597 
      oprot.writeI64(self.toShippingDate)
7598 
      oprot.writeFieldEnd()
3431 rajveer 7599 
    if self.providerId is not None:
3427 chandransh 7600 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7601 
      oprot.writeI64(self.providerId)
7602 
      oprot.writeFieldEnd()
3431 rajveer 7603 
    if self.warehouseId is not None:
3427 chandransh 7604 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7605 
      oprot.writeI64(self.warehouseId)
7606 
      oprot.writeFieldEnd()
3451 chandransh 7607 
    if self.cod is not None:
7608 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7609 
      oprot.writeBool(self.cod)
7610 
      oprot.writeFieldEnd()
3427 chandransh 7611 
    oprot.writeFieldStop()
7612 
    oprot.writeStructEnd()
7613 
 
3431 rajveer 7614 
  def validate(self):
7615 
    return
7616 
 
7617 
 
3427 chandransh 7618 
  def __repr__(self):
7619 
    L = ['%s=%r' % (key, value)
7620 
      for key, value in self.__dict__.iteritems()]
7621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7622 
 
7623 
  def __eq__(self, other):
7624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7625 
 
7626 
  def __ne__(self, other):
7627 
    return not (self == other)
7628 
 
7629 
class getOrdersByShippingDate_result:
7630 
  """
7631 
  Attributes:
7632 
   - success
7633 
   - ex
7634 
  """
7635 
 
7636 
  thrift_spec = (
7637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7639 
  )
7640 
 
7641 
  def __init__(self, success=None, ex=None,):
7642 
    self.success = success
7643 
    self.ex = ex
7644 
 
7645 
  def read(self, iprot):
7646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7648 
      return
7649 
    iprot.readStructBegin()
7650 
    while True:
7651 
      (fname, ftype, fid) = iprot.readFieldBegin()
7652 
      if ftype == TType.STOP:
7653 
        break
7654 
      if fid == 0:
7655 
        if ftype == TType.LIST:
7656 
          self.success = []
4133 chandransh 7657 
          (_etype66, _size63) = iprot.readListBegin()
7658 
          for _i67 in xrange(_size63):
7659 
            _elem68 = Order()
7660 
            _elem68.read(iprot)
7661 
            self.success.append(_elem68)
3427 chandransh 7662 
          iprot.readListEnd()
7663 
        else:
7664 
          iprot.skip(ftype)
7665 
      elif fid == 1:
7666 
        if ftype == TType.STRUCT:
7667 
          self.ex = TransactionServiceException()
7668 
          self.ex.read(iprot)
7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      else:
7672 
        iprot.skip(ftype)
7673 
      iprot.readFieldEnd()
7674 
    iprot.readStructEnd()
7675 
 
7676 
  def write(self, oprot):
7677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7679 
      return
7680 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7681 
    if self.success is not None:
3427 chandransh 7682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7684 
      for iter69 in self.success:
7685 
        iter69.write(oprot)
3427 chandransh 7686 
      oprot.writeListEnd()
7687 
      oprot.writeFieldEnd()
3431 rajveer 7688 
    if self.ex is not None:
3427 chandransh 7689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7690 
      self.ex.write(oprot)
7691 
      oprot.writeFieldEnd()
7692 
    oprot.writeFieldStop()
7693 
    oprot.writeStructEnd()
7694 
 
3431 rajveer 7695 
  def validate(self):
7696 
    return
7697 
 
7698 
 
3427 chandransh 7699 
  def __repr__(self):
7700 
    L = ['%s=%r' % (key, value)
7701 
      for key, value in self.__dict__.iteritems()]
7702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7703 
 
7704 
  def __eq__(self, other):
7705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7706 
 
7707 
  def __ne__(self, other):
7708 
    return not (self == other)
7709 
 
1382 varun.gupt 7710 
class getReturnableOrdersForCustomer_args:
7711 
  """
7712 
  Attributes:
7713 
   - customer_id
7714 
   - limit
7715 
  """
7716 
 
7717 
  thrift_spec = (
7718 
    None, # 0
7719 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7720 
    (2, TType.I64, 'limit', None, None, ), # 2
7721 
  )
7722 
 
7723 
  def __init__(self, customer_id=None, limit=None,):
7724 
    self.customer_id = customer_id
7725 
    self.limit = limit
7726 
 
7727 
  def read(self, iprot):
7728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7730 
      return
7731 
    iprot.readStructBegin()
7732 
    while True:
7733 
      (fname, ftype, fid) = iprot.readFieldBegin()
7734 
      if ftype == TType.STOP:
7735 
        break
7736 
      if fid == 1:
7737 
        if ftype == TType.I64:
7738 
          self.customer_id = iprot.readI64();
7739 
        else:
7740 
          iprot.skip(ftype)
7741 
      elif fid == 2:
7742 
        if ftype == TType.I64:
7743 
          self.limit = iprot.readI64();
7744 
        else:
7745 
          iprot.skip(ftype)
7746 
      else:
7747 
        iprot.skip(ftype)
7748 
      iprot.readFieldEnd()
7749 
    iprot.readStructEnd()
7750 
 
7751 
  def write(self, oprot):
7752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7754 
      return
7755 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7756 
    if self.customer_id is not None:
1382 varun.gupt 7757 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7758 
      oprot.writeI64(self.customer_id)
7759 
      oprot.writeFieldEnd()
3431 rajveer 7760 
    if self.limit is not None:
1382 varun.gupt 7761 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7762 
      oprot.writeI64(self.limit)
7763 
      oprot.writeFieldEnd()
7764 
    oprot.writeFieldStop()
7765 
    oprot.writeStructEnd()
7766 
 
3431 rajveer 7767 
  def validate(self):
7768 
    return
7769 
 
7770 
 
1382 varun.gupt 7771 
  def __repr__(self):
7772 
    L = ['%s=%r' % (key, value)
7773 
      for key, value in self.__dict__.iteritems()]
7774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7775 
 
7776 
  def __eq__(self, other):
7777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7778 
 
7779 
  def __ne__(self, other):
7780 
    return not (self == other)
7781 
 
7782 
class getReturnableOrdersForCustomer_result:
7783 
  """
7784 
  Attributes:
7785 
   - success
7786 
   - ex
7787 
  """
7788 
 
7789 
  thrift_spec = (
7790 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7792 
  )
7793 
 
7794 
  def __init__(self, success=None, ex=None,):
7795 
    self.success = success
7796 
    self.ex = ex
7797 
 
7798 
  def read(self, iprot):
7799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7801 
      return
7802 
    iprot.readStructBegin()
7803 
    while True:
7804 
      (fname, ftype, fid) = iprot.readFieldBegin()
7805 
      if ftype == TType.STOP:
7806 
        break
7807 
      if fid == 0:
7808 
        if ftype == TType.LIST:
7809 
          self.success = []
4133 chandransh 7810 
          (_etype73, _size70) = iprot.readListBegin()
7811 
          for _i74 in xrange(_size70):
7812 
            _elem75 = iprot.readI64();
7813 
            self.success.append(_elem75)
1382 varun.gupt 7814 
          iprot.readListEnd()
7815 
        else:
7816 
          iprot.skip(ftype)
7817 
      elif fid == 1:
7818 
        if ftype == TType.STRUCT:
7819 
          self.ex = TransactionServiceException()
7820 
          self.ex.read(iprot)
7821 
        else:
7822 
          iprot.skip(ftype)
7823 
      else:
7824 
        iprot.skip(ftype)
7825 
      iprot.readFieldEnd()
7826 
    iprot.readStructEnd()
7827 
 
7828 
  def write(self, oprot):
7829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7831 
      return
7832 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7833 
    if self.success is not None:
1382 varun.gupt 7834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7835 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7836 
      for iter76 in self.success:
7837 
        oprot.writeI64(iter76)
1382 varun.gupt 7838 
      oprot.writeListEnd()
7839 
      oprot.writeFieldEnd()
3431 rajveer 7840 
    if self.ex is not None:
1382 varun.gupt 7841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7842 
      self.ex.write(oprot)
7843 
      oprot.writeFieldEnd()
7844 
    oprot.writeFieldStop()
7845 
    oprot.writeStructEnd()
7846 
 
3431 rajveer 7847 
  def validate(self):
7848 
    return
7849 
 
7850 
 
1382 varun.gupt 7851 
  def __repr__(self):
7852 
    L = ['%s=%r' % (key, value)
7853 
      for key, value in self.__dict__.iteritems()]
7854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7855 
 
7856 
  def __eq__(self, other):
7857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7858 
 
7859 
  def __ne__(self, other):
7860 
    return not (self == other)
7861 
 
7862 
class getCancellableOrdersForCustomer_args:
7863 
  """
7864 
  Attributes:
7865 
   - customer_id
7866 
   - limit
7867 
  """
7868 
 
7869 
  thrift_spec = (
7870 
    None, # 0
7871 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7872 
    (2, TType.I64, 'limit', None, None, ), # 2
7873 
  )
7874 
 
7875 
  def __init__(self, customer_id=None, limit=None,):
7876 
    self.customer_id = customer_id
7877 
    self.limit = limit
7878 
 
7879 
  def read(self, iprot):
7880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7882 
      return
7883 
    iprot.readStructBegin()
7884 
    while True:
7885 
      (fname, ftype, fid) = iprot.readFieldBegin()
7886 
      if ftype == TType.STOP:
7887 
        break
7888 
      if fid == 1:
7889 
        if ftype == TType.I64:
7890 
          self.customer_id = iprot.readI64();
7891 
        else:
7892 
          iprot.skip(ftype)
7893 
      elif fid == 2:
7894 
        if ftype == TType.I64:
7895 
          self.limit = iprot.readI64();
7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      else:
7899 
        iprot.skip(ftype)
7900 
      iprot.readFieldEnd()
7901 
    iprot.readStructEnd()
7902 
 
7903 
  def write(self, oprot):
7904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7906 
      return
7907 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7908 
    if self.customer_id is not None:
1382 varun.gupt 7909 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7910 
      oprot.writeI64(self.customer_id)
7911 
      oprot.writeFieldEnd()
3431 rajveer 7912 
    if self.limit is not None:
1382 varun.gupt 7913 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7914 
      oprot.writeI64(self.limit)
7915 
      oprot.writeFieldEnd()
7916 
    oprot.writeFieldStop()
7917 
    oprot.writeStructEnd()
7918 
 
3431 rajveer 7919 
  def validate(self):
7920 
    return
7921 
 
7922 
 
1382 varun.gupt 7923 
  def __repr__(self):
7924 
    L = ['%s=%r' % (key, value)
7925 
      for key, value in self.__dict__.iteritems()]
7926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7927 
 
7928 
  def __eq__(self, other):
7929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7930 
 
7931 
  def __ne__(self, other):
7932 
    return not (self == other)
7933 
 
7934 
class getCancellableOrdersForCustomer_result:
7935 
  """
7936 
  Attributes:
7937 
   - success
7938 
   - ex
7939 
  """
7940 
 
7941 
  thrift_spec = (
7942 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7944 
  )
7945 
 
7946 
  def __init__(self, success=None, ex=None,):
7947 
    self.success = success
7948 
    self.ex = ex
7949 
 
7950 
  def read(self, iprot):
7951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7953 
      return
7954 
    iprot.readStructBegin()
7955 
    while True:
7956 
      (fname, ftype, fid) = iprot.readFieldBegin()
7957 
      if ftype == TType.STOP:
7958 
        break
7959 
      if fid == 0:
7960 
        if ftype == TType.LIST:
7961 
          self.success = []
4133 chandransh 7962 
          (_etype80, _size77) = iprot.readListBegin()
7963 
          for _i81 in xrange(_size77):
7964 
            _elem82 = iprot.readI64();
7965 
            self.success.append(_elem82)
1382 varun.gupt 7966 
          iprot.readListEnd()
7967 
        else:
7968 
          iprot.skip(ftype)
7969 
      elif fid == 1:
7970 
        if ftype == TType.STRUCT:
7971 
          self.ex = TransactionServiceException()
7972 
          self.ex.read(iprot)
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      else:
7976 
        iprot.skip(ftype)
7977 
      iprot.readFieldEnd()
7978 
    iprot.readStructEnd()
7979 
 
7980 
  def write(self, oprot):
7981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7983 
      return
7984 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7985 
    if self.success is not None:
1382 varun.gupt 7986 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7987 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7988 
      for iter83 in self.success:
7989 
        oprot.writeI64(iter83)
1382 varun.gupt 7990 
      oprot.writeListEnd()
7991 
      oprot.writeFieldEnd()
3431 rajveer 7992 
    if self.ex is not None:
1382 varun.gupt 7993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7994 
      self.ex.write(oprot)
7995 
      oprot.writeFieldEnd()
7996 
    oprot.writeFieldStop()
7997 
    oprot.writeStructEnd()
7998 
 
3431 rajveer 7999 
  def validate(self):
8000 
    return
8001 
 
8002 
 
1382 varun.gupt 8003 
  def __repr__(self):
8004 
    L = ['%s=%r' % (key, value)
8005 
      for key, value in self.__dict__.iteritems()]
8006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8007 
 
8008 
  def __eq__(self, other):
8009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8010 
 
8011 
  def __ne__(self, other):
8012 
    return not (self == other)
8013 
 
483 rajveer 8014 
class changeOrderStatus_args:
94 ashish 8015 
  """
8016 
  Attributes:
483 rajveer 8017 
   - orderId
8018 
   - status
8019 
   - description
94 ashish 8020 
  """
8021 
 
8022 
  thrift_spec = (
8023 
    None, # 0
483 rajveer 8024 
    (1, TType.I64, 'orderId', None, None, ), # 1
8025 
    (2, TType.I32, 'status', None, None, ), # 2
8026 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8027 
  )
8028 
 
483 rajveer 8029 
  def __init__(self, orderId=None, status=None, description=None,):
8030 
    self.orderId = orderId
8031 
    self.status = status
8032 
    self.description = description
94 ashish 8033 
 
8034 
  def read(self, iprot):
8035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8037 
      return
8038 
    iprot.readStructBegin()
8039 
    while True:
8040 
      (fname, ftype, fid) = iprot.readFieldBegin()
8041 
      if ftype == TType.STOP:
8042 
        break
8043 
      if fid == 1:
8044 
        if ftype == TType.I64:
483 rajveer 8045 
          self.orderId = iprot.readI64();
94 ashish 8046 
        else:
8047 
          iprot.skip(ftype)
8048 
      elif fid == 2:
483 rajveer 8049 
        if ftype == TType.I32:
8050 
          self.status = iprot.readI32();
94 ashish 8051 
        else:
8052 
          iprot.skip(ftype)
483 rajveer 8053 
      elif fid == 3:
8054 
        if ftype == TType.STRING:
8055 
          self.description = iprot.readString();
8056 
        else:
8057 
          iprot.skip(ftype)
94 ashish 8058 
      else:
8059 
        iprot.skip(ftype)
8060 
      iprot.readFieldEnd()
8061 
    iprot.readStructEnd()
8062 
 
8063 
  def write(self, oprot):
8064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8066 
      return
483 rajveer 8067 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8068 
    if self.orderId is not None:
483 rajveer 8069 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8070 
      oprot.writeI64(self.orderId)
94 ashish 8071 
      oprot.writeFieldEnd()
3431 rajveer 8072 
    if self.status is not None:
483 rajveer 8073 
      oprot.writeFieldBegin('status', TType.I32, 2)
8074 
      oprot.writeI32(self.status)
94 ashish 8075 
      oprot.writeFieldEnd()
3431 rajveer 8076 
    if self.description is not None:
483 rajveer 8077 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8078 
      oprot.writeString(self.description)
8079 
      oprot.writeFieldEnd()
94 ashish 8080 
    oprot.writeFieldStop()
8081 
    oprot.writeStructEnd()
8082 
 
3431 rajveer 8083 
  def validate(self):
8084 
    return
8085 
 
8086 
 
94 ashish 8087 
  def __repr__(self):
8088 
    L = ['%s=%r' % (key, value)
8089 
      for key, value in self.__dict__.iteritems()]
8090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8091 
 
8092 
  def __eq__(self, other):
8093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8094 
 
8095 
  def __ne__(self, other):
8096 
    return not (self == other)
8097 
 
483 rajveer 8098 
class changeOrderStatus_result:
94 ashish 8099 
  """
8100 
  Attributes:
8101 
   - success
8102 
   - ex
8103 
  """
8104 
 
8105 
  thrift_spec = (
8106 
    (0, TType.BOOL, 'success', None, None, ), # 0
8107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8108 
  )
8109 
 
8110 
  def __init__(self, success=None, ex=None,):
8111 
    self.success = success
8112 
    self.ex = ex
8113 
 
8114 
  def read(self, iprot):
8115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8117 
      return
8118 
    iprot.readStructBegin()
8119 
    while True:
8120 
      (fname, ftype, fid) = iprot.readFieldBegin()
8121 
      if ftype == TType.STOP:
8122 
        break
8123 
      if fid == 0:
8124 
        if ftype == TType.BOOL:
8125 
          self.success = iprot.readBool();
8126 
        else:
8127 
          iprot.skip(ftype)
8128 
      elif fid == 1:
8129 
        if ftype == TType.STRUCT:
8130 
          self.ex = TransactionServiceException()
8131 
          self.ex.read(iprot)
8132 
        else:
8133 
          iprot.skip(ftype)
8134 
      else:
8135 
        iprot.skip(ftype)
8136 
      iprot.readFieldEnd()
8137 
    iprot.readStructEnd()
8138 
 
8139 
  def write(self, oprot):
8140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8142 
      return
483 rajveer 8143 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8144 
    if self.success is not None:
94 ashish 8145 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8146 
      oprot.writeBool(self.success)
8147 
      oprot.writeFieldEnd()
3431 rajveer 8148 
    if self.ex is not None:
94 ashish 8149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8150 
      self.ex.write(oprot)
8151 
      oprot.writeFieldEnd()
8152 
    oprot.writeFieldStop()
8153 
    oprot.writeStructEnd()
8154 
 
3431 rajveer 8155 
  def validate(self):
8156 
    return
8157 
 
8158 
 
94 ashish 8159 
  def __repr__(self):
8160 
    L = ['%s=%r' % (key, value)
8161 
      for key, value in self.__dict__.iteritems()]
8162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8163 
 
8164 
  def __eq__(self, other):
8165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8166 
 
8167 
  def __ne__(self, other):
8168 
    return not (self == other)
8169 
 
3064 chandransh 8170 
class getOrdersForTransaction_args:
494 rajveer 8171 
  """
8172 
  Attributes:
3064 chandransh 8173 
   - transactionId
8174 
   - customerId
494 rajveer 8175 
  """
8176 
 
8177 
  thrift_spec = (
8178 
    None, # 0
3064 chandransh 8179 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8180 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8181 
  )
8182 
 
3064 chandransh 8183 
  def __init__(self, transactionId=None, customerId=None,):
8184 
    self.transactionId = transactionId
8185 
    self.customerId = customerId
494 rajveer 8186 
 
8187 
  def read(self, iprot):
8188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8190 
      return
8191 
    iprot.readStructBegin()
8192 
    while True:
8193 
      (fname, ftype, fid) = iprot.readFieldBegin()
8194 
      if ftype == TType.STOP:
8195 
        break
8196 
      if fid == 1:
8197 
        if ftype == TType.I64:
3064 chandransh 8198 
          self.transactionId = iprot.readI64();
494 rajveer 8199 
        else:
8200 
          iprot.skip(ftype)
8201 
      elif fid == 2:
3064 chandransh 8202 
        if ftype == TType.I64:
8203 
          self.customerId = iprot.readI64();
494 rajveer 8204 
        else:
8205 
          iprot.skip(ftype)
8206 
      else:
8207 
        iprot.skip(ftype)
8208 
      iprot.readFieldEnd()
8209 
    iprot.readStructEnd()
8210 
 
8211 
  def write(self, oprot):
8212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8214 
      return
3064 chandransh 8215 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8216 
    if self.transactionId is not None:
3064 chandransh 8217 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8218 
      oprot.writeI64(self.transactionId)
494 rajveer 8219 
      oprot.writeFieldEnd()
3431 rajveer 8220 
    if self.customerId is not None:
3064 chandransh 8221 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8222 
      oprot.writeI64(self.customerId)
494 rajveer 8223 
      oprot.writeFieldEnd()
8224 
    oprot.writeFieldStop()
8225 
    oprot.writeStructEnd()
8226 
 
3431 rajveer 8227 
  def validate(self):
8228 
    return
8229 
 
8230 
 
494 rajveer 8231 
  def __repr__(self):
8232 
    L = ['%s=%r' % (key, value)
8233 
      for key, value in self.__dict__.iteritems()]
8234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8235 
 
8236 
  def __eq__(self, other):
8237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8238 
 
8239 
  def __ne__(self, other):
8240 
    return not (self == other)
8241 
 
3064 chandransh 8242 
class getOrdersForTransaction_result:
494 rajveer 8243 
  """
8244 
  Attributes:
8245 
   - success
8246 
   - ex
8247 
  """
8248 
 
8249 
  thrift_spec = (
3064 chandransh 8250 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8252 
  )
8253 
 
8254 
  def __init__(self, success=None, ex=None,):
8255 
    self.success = success
8256 
    self.ex = ex
8257 
 
8258 
  def read(self, iprot):
8259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8261 
      return
8262 
    iprot.readStructBegin()
8263 
    while True:
8264 
      (fname, ftype, fid) = iprot.readFieldBegin()
8265 
      if ftype == TType.STOP:
8266 
        break
8267 
      if fid == 0:
3064 chandransh 8268 
        if ftype == TType.LIST:
8269 
          self.success = []
4133 chandransh 8270 
          (_etype87, _size84) = iprot.readListBegin()
8271 
          for _i88 in xrange(_size84):
8272 
            _elem89 = Order()
8273 
            _elem89.read(iprot)
8274 
            self.success.append(_elem89)
3064 chandransh 8275 
          iprot.readListEnd()
494 rajveer 8276 
        else:
8277 
          iprot.skip(ftype)
8278 
      elif fid == 1:
8279 
        if ftype == TType.STRUCT:
8280 
          self.ex = TransactionServiceException()
8281 
          self.ex.read(iprot)
8282 
        else:
8283 
          iprot.skip(ftype)
8284 
      else:
8285 
        iprot.skip(ftype)
8286 
      iprot.readFieldEnd()
8287 
    iprot.readStructEnd()
8288 
 
8289 
  def write(self, oprot):
8290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8292 
      return
3064 chandransh 8293 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8294 
    if self.success is not None:
3064 chandransh 8295 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8296 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8297 
      for iter90 in self.success:
8298 
        iter90.write(oprot)
3064 chandransh 8299 
      oprot.writeListEnd()
494 rajveer 8300 
      oprot.writeFieldEnd()
3431 rajveer 8301 
    if self.ex is not None:
494 rajveer 8302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8303 
      self.ex.write(oprot)
8304 
      oprot.writeFieldEnd()
8305 
    oprot.writeFieldStop()
8306 
    oprot.writeStructEnd()
8307 
 
3431 rajveer 8308 
  def validate(self):
8309 
    return
8310 
 
8311 
 
494 rajveer 8312 
  def __repr__(self):
8313 
    L = ['%s=%r' % (key, value)
8314 
      for key, value in self.__dict__.iteritems()]
8315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8316 
 
8317 
  def __eq__(self, other):
8318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8319 
 
8320 
  def __ne__(self, other):
8321 
    return not (self == other)
8322 
 
3064 chandransh 8323 
class getOrdersForCustomer_args:
1149 chandransh 8324 
  """
8325 
  Attributes:
3064 chandransh 8326 
   - customerId
8327 
   - from_date
8328 
   - to_date
8329 
   - statuses
1149 chandransh 8330 
  """
8331 
 
8332 
  thrift_spec = (
8333 
    None, # 0
3064 chandransh 8334 
    (1, TType.I64, 'customerId', None, None, ), # 1
8335 
    (2, TType.I64, 'from_date', None, None, ), # 2
8336 
    (3, TType.I64, 'to_date', None, None, ), # 3
8337 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8338 
  )
8339 
 
3064 chandransh 8340 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8341 
    self.customerId = customerId
8342 
    self.from_date = from_date
8343 
    self.to_date = to_date
8344 
    self.statuses = statuses
1149 chandransh 8345 
 
8346 
  def read(self, iprot):
8347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8349 
      return
8350 
    iprot.readStructBegin()
8351 
    while True:
8352 
      (fname, ftype, fid) = iprot.readFieldBegin()
8353 
      if ftype == TType.STOP:
8354 
        break
8355 
      if fid == 1:
8356 
        if ftype == TType.I64:
3064 chandransh 8357 
          self.customerId = iprot.readI64();
1149 chandransh 8358 
        else:
8359 
          iprot.skip(ftype)
8360 
      elif fid == 2:
8361 
        if ftype == TType.I64:
3064 chandransh 8362 
          self.from_date = iprot.readI64();
1149 chandransh 8363 
        else:
8364 
          iprot.skip(ftype)
2783 chandransh 8365 
      elif fid == 3:
8366 
        if ftype == TType.I64:
3064 chandransh 8367 
          self.to_date = iprot.readI64();
2783 chandransh 8368 
        else:
8369 
          iprot.skip(ftype)
8370 
      elif fid == 4:
3064 chandransh 8371 
        if ftype == TType.LIST:
8372 
          self.statuses = []
4133 chandransh 8373 
          (_etype94, _size91) = iprot.readListBegin()
8374 
          for _i95 in xrange(_size91):
8375 
            _elem96 = iprot.readI32();
8376 
            self.statuses.append(_elem96)
3064 chandransh 8377 
          iprot.readListEnd()
2783 chandransh 8378 
        else:
8379 
          iprot.skip(ftype)
1149 chandransh 8380 
      else:
8381 
        iprot.skip(ftype)
8382 
      iprot.readFieldEnd()
8383 
    iprot.readStructEnd()
8384 
 
8385 
  def write(self, oprot):
8386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8388 
      return
3064 chandransh 8389 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8390 
    if self.customerId is not None:
3064 chandransh 8391 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8392 
      oprot.writeI64(self.customerId)
1149 chandransh 8393 
      oprot.writeFieldEnd()
3431 rajveer 8394 
    if self.from_date is not None:
3064 chandransh 8395 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8396 
      oprot.writeI64(self.from_date)
1149 chandransh 8397 
      oprot.writeFieldEnd()
3431 rajveer 8398 
    if self.to_date is not None:
3064 chandransh 8399 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8400 
      oprot.writeI64(self.to_date)
2783 chandransh 8401 
      oprot.writeFieldEnd()
3431 rajveer 8402 
    if self.statuses is not None:
3064 chandransh 8403 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8404 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8405 
      for iter97 in self.statuses:
8406 
        oprot.writeI32(iter97)
3064 chandransh 8407 
      oprot.writeListEnd()
2783 chandransh 8408 
      oprot.writeFieldEnd()
1149 chandransh 8409 
    oprot.writeFieldStop()
8410 
    oprot.writeStructEnd()
8411 
 
3431 rajveer 8412 
  def validate(self):
8413 
    return
8414 
 
8415 
 
1149 chandransh 8416 
  def __repr__(self):
8417 
    L = ['%s=%r' % (key, value)
8418 
      for key, value in self.__dict__.iteritems()]
8419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8420 
 
8421 
  def __eq__(self, other):
8422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8423 
 
8424 
  def __ne__(self, other):
8425 
    return not (self == other)
8426 
 
3064 chandransh 8427 
class getOrdersForCustomer_result:
1149 chandransh 8428 
  """
8429 
  Attributes:
8430 
   - success
8431 
   - ex
8432 
  """
8433 
 
8434 
  thrift_spec = (
3064 chandransh 8435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8437 
  )
8438 
 
8439 
  def __init__(self, success=None, ex=None,):
8440 
    self.success = success
8441 
    self.ex = ex
8442 
 
8443 
  def read(self, iprot):
8444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8446 
      return
8447 
    iprot.readStructBegin()
8448 
    while True:
8449 
      (fname, ftype, fid) = iprot.readFieldBegin()
8450 
      if ftype == TType.STOP:
8451 
        break
8452 
      if fid == 0:
3064 chandransh 8453 
        if ftype == TType.LIST:
8454 
          self.success = []
4133 chandransh 8455 
          (_etype101, _size98) = iprot.readListBegin()
8456 
          for _i102 in xrange(_size98):
8457 
            _elem103 = Order()
8458 
            _elem103.read(iprot)
8459 
            self.success.append(_elem103)
3064 chandransh 8460 
          iprot.readListEnd()
1149 chandransh 8461 
        else:
8462 
          iprot.skip(ftype)
8463 
      elif fid == 1:
8464 
        if ftype == TType.STRUCT:
8465 
          self.ex = TransactionServiceException()
8466 
          self.ex.read(iprot)
8467 
        else:
8468 
          iprot.skip(ftype)
8469 
      else:
8470 
        iprot.skip(ftype)
8471 
      iprot.readFieldEnd()
8472 
    iprot.readStructEnd()
8473 
 
8474 
  def write(self, oprot):
8475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8477 
      return
3064 chandransh 8478 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8479 
    if self.success is not None:
3064 chandransh 8480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8482 
      for iter104 in self.success:
8483 
        iter104.write(oprot)
3064 chandransh 8484 
      oprot.writeListEnd()
1149 chandransh 8485 
      oprot.writeFieldEnd()
3431 rajveer 8486 
    if self.ex is not None:
1149 chandransh 8487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8488 
      self.ex.write(oprot)
8489 
      oprot.writeFieldEnd()
8490 
    oprot.writeFieldStop()
8491 
    oprot.writeStructEnd()
8492 
 
3431 rajveer 8493 
  def validate(self):
8494 
    return
8495 
 
8496 
 
1149 chandransh 8497 
  def __repr__(self):
8498 
    L = ['%s=%r' % (key, value)
8499 
      for key, value in self.__dict__.iteritems()]
8500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8501 
 
8502 
  def __eq__(self, other):
8503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8504 
 
8505 
  def __ne__(self, other):
8506 
    return not (self == other)
8507 
 
3064 chandransh 8508 
class createOrder_args:
921 rajveer 8509 
  """
8510 
  Attributes:
3064 chandransh 8511 
   - order
921 rajveer 8512 
  """
8513 
 
8514 
  thrift_spec = (
8515 
    None, # 0
3064 chandransh 8516 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8517 
  )
8518 
 
3064 chandransh 8519 
  def __init__(self, order=None,):
8520 
    self.order = order
921 rajveer 8521 
 
8522 
  def read(self, iprot):
8523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8525 
      return
8526 
    iprot.readStructBegin()
8527 
    while True:
8528 
      (fname, ftype, fid) = iprot.readFieldBegin()
8529 
      if ftype == TType.STOP:
8530 
        break
8531 
      if fid == 1:
3064 chandransh 8532 
        if ftype == TType.STRUCT:
8533 
          self.order = Order()
8534 
          self.order.read(iprot)
921 rajveer 8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      else:
8538 
        iprot.skip(ftype)
8539 
      iprot.readFieldEnd()
8540 
    iprot.readStructEnd()
8541 
 
8542 
  def write(self, oprot):
8543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8545 
      return
3064 chandransh 8546 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8547 
    if self.order is not None:
3064 chandransh 8548 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8549 
      self.order.write(oprot)
921 rajveer 8550 
      oprot.writeFieldEnd()
8551 
    oprot.writeFieldStop()
8552 
    oprot.writeStructEnd()
8553 
 
3431 rajveer 8554 
  def validate(self):
8555 
    return
8556 
 
8557 
 
921 rajveer 8558 
  def __repr__(self):
8559 
    L = ['%s=%r' % (key, value)
8560 
      for key, value in self.__dict__.iteritems()]
8561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8562 
 
8563 
  def __eq__(self, other):
8564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8565 
 
8566 
  def __ne__(self, other):
8567 
    return not (self == other)
8568 
 
3064 chandransh 8569 
class createOrder_result:
921 rajveer 8570 
  """
8571 
  Attributes:
8572 
   - success
8573 
   - ex
8574 
  """
8575 
 
8576 
  thrift_spec = (
3064 chandransh 8577 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8579 
  )
8580 
 
8581 
  def __init__(self, success=None, ex=None,):
8582 
    self.success = success
8583 
    self.ex = ex
8584 
 
8585 
  def read(self, iprot):
8586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8588 
      return
8589 
    iprot.readStructBegin()
8590 
    while True:
8591 
      (fname, ftype, fid) = iprot.readFieldBegin()
8592 
      if ftype == TType.STOP:
8593 
        break
8594 
      if fid == 0:
3064 chandransh 8595 
        if ftype == TType.I64:
8596 
          self.success = iprot.readI64();
921 rajveer 8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      elif fid == 1:
8600 
        if ftype == TType.STRUCT:
8601 
          self.ex = TransactionServiceException()
8602 
          self.ex.read(iprot)
8603 
        else:
8604 
          iprot.skip(ftype)
8605 
      else:
8606 
        iprot.skip(ftype)
8607 
      iprot.readFieldEnd()
8608 
    iprot.readStructEnd()
8609 
 
8610 
  def write(self, oprot):
8611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8613 
      return
3064 chandransh 8614 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8615 
    if self.success is not None:
3064 chandransh 8616 
      oprot.writeFieldBegin('success', TType.I64, 0)
8617 
      oprot.writeI64(self.success)
921 rajveer 8618 
      oprot.writeFieldEnd()
3431 rajveer 8619 
    if self.ex is not None:
921 rajveer 8620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8621 
      self.ex.write(oprot)
8622 
      oprot.writeFieldEnd()
8623 
    oprot.writeFieldStop()
8624 
    oprot.writeStructEnd()
8625 
 
3431 rajveer 8626 
  def validate(self):
8627 
    return
8628 
 
8629 
 
921 rajveer 8630 
  def __repr__(self):
8631 
    L = ['%s=%r' % (key, value)
8632 
      for key, value in self.__dict__.iteritems()]
8633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8634 
 
8635 
  def __eq__(self, other):
8636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8637 
 
8638 
  def __ne__(self, other):
8639 
    return not (self == other)
8640 
 
3064 chandransh 8641 
class getOrder_args:
921 rajveer 8642 
  """
8643 
  Attributes:
3064 chandransh 8644 
   - id
921 rajveer 8645 
  """
8646 
 
8647 
  thrift_spec = (
8648 
    None, # 0
3064 chandransh 8649 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8650 
  )
8651 
 
3064 chandransh 8652 
  def __init__(self, id=None,):
8653 
    self.id = id
921 rajveer 8654 
 
8655 
  def read(self, iprot):
8656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8658 
      return
8659 
    iprot.readStructBegin()
8660 
    while True:
8661 
      (fname, ftype, fid) = iprot.readFieldBegin()
8662 
      if ftype == TType.STOP:
8663 
        break
8664 
      if fid == 1:
8665 
        if ftype == TType.I64:
3064 chandransh 8666 
          self.id = iprot.readI64();
921 rajveer 8667 
        else:
8668 
          iprot.skip(ftype)
8669 
      else:
8670 
        iprot.skip(ftype)
8671 
      iprot.readFieldEnd()
8672 
    iprot.readStructEnd()
8673 
 
8674 
  def write(self, oprot):
8675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8677 
      return
3064 chandransh 8678 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8679 
    if self.id is not None:
3064 chandransh 8680 
      oprot.writeFieldBegin('id', TType.I64, 1)
8681 
      oprot.writeI64(self.id)
921 rajveer 8682 
      oprot.writeFieldEnd()
8683 
    oprot.writeFieldStop()
8684 
    oprot.writeStructEnd()
8685 
 
3431 rajveer 8686 
  def validate(self):
8687 
    return
8688 
 
8689 
 
921 rajveer 8690 
  def __repr__(self):
8691 
    L = ['%s=%r' % (key, value)
8692 
      for key, value in self.__dict__.iteritems()]
8693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8694 
 
8695 
  def __eq__(self, other):
8696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8697 
 
8698 
  def __ne__(self, other):
8699 
    return not (self == other)
8700 
 
3064 chandransh 8701 
class getOrder_result:
921 rajveer 8702 
  """
8703 
  Attributes:
8704 
   - success
8705 
   - ex
8706 
  """
8707 
 
8708 
  thrift_spec = (
3064 chandransh 8709 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8711 
  )
8712 
 
8713 
  def __init__(self, success=None, ex=None,):
8714 
    self.success = success
8715 
    self.ex = ex
8716 
 
8717 
  def read(self, iprot):
8718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8720 
      return
8721 
    iprot.readStructBegin()
8722 
    while True:
8723 
      (fname, ftype, fid) = iprot.readFieldBegin()
8724 
      if ftype == TType.STOP:
8725 
        break
8726 
      if fid == 0:
3064 chandransh 8727 
        if ftype == TType.STRUCT:
8728 
          self.success = Order()
8729 
          self.success.read(iprot)
921 rajveer 8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      elif fid == 1:
8733 
        if ftype == TType.STRUCT:
8734 
          self.ex = TransactionServiceException()
8735 
          self.ex.read(iprot)
8736 
        else:
8737 
          iprot.skip(ftype)
8738 
      else:
8739 
        iprot.skip(ftype)
8740 
      iprot.readFieldEnd()
8741 
    iprot.readStructEnd()
8742 
 
8743 
  def write(self, oprot):
8744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8746 
      return
3064 chandransh 8747 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8748 
    if self.success is not None:
3064 chandransh 8749 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8750 
      self.success.write(oprot)
921 rajveer 8751 
      oprot.writeFieldEnd()
3431 rajveer 8752 
    if self.ex is not None:
921 rajveer 8753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8754 
      self.ex.write(oprot)
8755 
      oprot.writeFieldEnd()
8756 
    oprot.writeFieldStop()
8757 
    oprot.writeStructEnd()
8758 
 
3431 rajveer 8759 
  def validate(self):
8760 
    return
8761 
 
8762 
 
921 rajveer 8763 
  def __repr__(self):
8764 
    L = ['%s=%r' % (key, value)
8765 
      for key, value in self.__dict__.iteritems()]
8766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8767 
 
8768 
  def __eq__(self, other):
8769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8770 
 
8771 
  def __ne__(self, other):
8772 
    return not (self == other)
8773 
 
3064 chandransh 8774 
class getLineItemsForOrder_args:
94 ashish 8775 
  """
8776 
  Attributes:
3064 chandransh 8777 
   - orderId
94 ashish 8778 
  """
8779 
 
8780 
  thrift_spec = (
8781 
    None, # 0
3064 chandransh 8782 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8783 
  )
8784 
 
3064 chandransh 8785 
  def __init__(self, orderId=None,):
8786 
    self.orderId = orderId
94 ashish 8787 
 
8788 
  def read(self, iprot):
8789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8791 
      return
8792 
    iprot.readStructBegin()
8793 
    while True:
8794 
      (fname, ftype, fid) = iprot.readFieldBegin()
8795 
      if ftype == TType.STOP:
8796 
        break
8797 
      if fid == 1:
8798 
        if ftype == TType.I64:
3064 chandransh 8799 
          self.orderId = iprot.readI64();
94 ashish 8800 
        else:
8801 
          iprot.skip(ftype)
8802 
      else:
8803 
        iprot.skip(ftype)
8804 
      iprot.readFieldEnd()
8805 
    iprot.readStructEnd()
8806 
 
8807 
  def write(self, oprot):
8808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8810 
      return
3064 chandransh 8811 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8812 
    if self.orderId is not None:
3064 chandransh 8813 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8814 
      oprot.writeI64(self.orderId)
94 ashish 8815 
      oprot.writeFieldEnd()
8816 
    oprot.writeFieldStop()
8817 
    oprot.writeStructEnd()
8818 
 
3431 rajveer 8819 
  def validate(self):
8820 
    return
8821 
 
8822 
 
94 ashish 8823 
  def __repr__(self):
8824 
    L = ['%s=%r' % (key, value)
8825 
      for key, value in self.__dict__.iteritems()]
8826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8827 
 
8828 
  def __eq__(self, other):
8829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8830 
 
8831 
  def __ne__(self, other):
8832 
    return not (self == other)
8833 
 
3064 chandransh 8834 
class getLineItemsForOrder_result:
94 ashish 8835 
  """
8836 
  Attributes:
8837 
   - success
8838 
   - ex
8839 
  """
8840 
 
8841 
  thrift_spec = (
3064 chandransh 8842 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8844 
  )
8845 
 
8846 
  def __init__(self, success=None, ex=None,):
8847 
    self.success = success
8848 
    self.ex = ex
8849 
 
8850 
  def read(self, iprot):
8851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8853 
      return
8854 
    iprot.readStructBegin()
8855 
    while True:
8856 
      (fname, ftype, fid) = iprot.readFieldBegin()
8857 
      if ftype == TType.STOP:
8858 
        break
8859 
      if fid == 0:
483 rajveer 8860 
        if ftype == TType.LIST:
8861 
          self.success = []
4133 chandransh 8862 
          (_etype108, _size105) = iprot.readListBegin()
8863 
          for _i109 in xrange(_size105):
8864 
            _elem110 = LineItem()
8865 
            _elem110.read(iprot)
8866 
            self.success.append(_elem110)
483 rajveer 8867 
          iprot.readListEnd()
94 ashish 8868 
        else:
8869 
          iprot.skip(ftype)
8870 
      elif fid == 1:
8871 
        if ftype == TType.STRUCT:
8872 
          self.ex = TransactionServiceException()
8873 
          self.ex.read(iprot)
8874 
        else:
8875 
          iprot.skip(ftype)
8876 
      else:
8877 
        iprot.skip(ftype)
8878 
      iprot.readFieldEnd()
8879 
    iprot.readStructEnd()
8880 
 
8881 
  def write(self, oprot):
8882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8884 
      return
3064 chandransh 8885 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8886 
    if self.success is not None:
483 rajveer 8887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8889 
      for iter111 in self.success:
8890 
        iter111.write(oprot)
483 rajveer 8891 
      oprot.writeListEnd()
94 ashish 8892 
      oprot.writeFieldEnd()
3431 rajveer 8893 
    if self.ex is not None:
94 ashish 8894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8895 
      self.ex.write(oprot)
8896 
      oprot.writeFieldEnd()
8897 
    oprot.writeFieldStop()
8898 
    oprot.writeStructEnd()
8899 
 
3431 rajveer 8900 
  def validate(self):
8901 
    return
8902 
 
8903 
 
94 ashish 8904 
  def __repr__(self):
8905 
    L = ['%s=%r' % (key, value)
8906 
      for key, value in self.__dict__.iteritems()]
8907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8908 
 
8909 
  def __eq__(self, other):
8910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8911 
 
8912 
  def __ne__(self, other):
8913 
    return not (self == other)
8914 
 
3064 chandransh 8915 
class getOrderForCustomer_args:
94 ashish 8916 
  """
8917 
  Attributes:
3064 chandransh 8918 
   - orderId
483 rajveer 8919 
   - customerId
94 ashish 8920 
  """
8921 
 
8922 
  thrift_spec = (
8923 
    None, # 0
3064 chandransh 8924 
    (1, TType.I64, 'orderId', None, None, ), # 1
8925 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8926 
  )
8927 
 
3064 chandransh 8928 
  def __init__(self, orderId=None, customerId=None,):
8929 
    self.orderId = orderId
483 rajveer 8930 
    self.customerId = customerId
94 ashish 8931 
 
8932 
  def read(self, iprot):
8933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8935 
      return
8936 
    iprot.readStructBegin()
8937 
    while True:
8938 
      (fname, ftype, fid) = iprot.readFieldBegin()
8939 
      if ftype == TType.STOP:
8940 
        break
8941 
      if fid == 1:
8942 
        if ftype == TType.I64:
3064 chandransh 8943 
          self.orderId = iprot.readI64();
94 ashish 8944 
        else:
8945 
          iprot.skip(ftype)
8946 
      elif fid == 2:
8947 
        if ftype == TType.I64:
3064 chandransh 8948 
          self.customerId = iprot.readI64();
94 ashish 8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      else:
8952 
        iprot.skip(ftype)
8953 
      iprot.readFieldEnd()
8954 
    iprot.readStructEnd()
8955 
 
8956 
  def write(self, oprot):
8957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8959 
      return
3064 chandransh 8960 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8961 
    if self.orderId is not None:
3064 chandransh 8962 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8963 
      oprot.writeI64(self.orderId)
8964 
      oprot.writeFieldEnd()
3431 rajveer 8965 
    if self.customerId is not None:
3064 chandransh 8966 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8967 
      oprot.writeI64(self.customerId)
94 ashish 8968 
      oprot.writeFieldEnd()
8969 
    oprot.writeFieldStop()
8970 
    oprot.writeStructEnd()
8971 
 
3431 rajveer 8972 
  def validate(self):
8973 
    return
8974 
 
8975 
 
94 ashish 8976 
  def __repr__(self):
8977 
    L = ['%s=%r' % (key, value)
8978 
      for key, value in self.__dict__.iteritems()]
8979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8980 
 
8981 
  def __eq__(self, other):
8982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8983 
 
8984 
  def __ne__(self, other):
8985 
    return not (self == other)
8986 
 
3064 chandransh 8987 
class getOrderForCustomer_result:
94 ashish 8988 
  """
8989 
  Attributes:
8990 
   - success
8991 
   - ex
8992 
  """
8993 
 
8994 
  thrift_spec = (
3064 chandransh 8995 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8997 
  )
8998 
 
8999 
  def __init__(self, success=None, ex=None,):
9000 
    self.success = success
9001 
    self.ex = ex
9002 
 
9003 
  def read(self, iprot):
9004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9006 
      return
9007 
    iprot.readStructBegin()
9008 
    while True:
9009 
      (fname, ftype, fid) = iprot.readFieldBegin()
9010 
      if ftype == TType.STOP:
9011 
        break
9012 
      if fid == 0:
3064 chandransh 9013 
        if ftype == TType.STRUCT:
9014 
          self.success = Order()
9015 
          self.success.read(iprot)
94 ashish 9016 
        else:
9017 
          iprot.skip(ftype)
9018 
      elif fid == 1:
9019 
        if ftype == TType.STRUCT:
9020 
          self.ex = TransactionServiceException()
9021 
          self.ex.read(iprot)
9022 
        else:
9023 
          iprot.skip(ftype)
9024 
      else:
9025 
        iprot.skip(ftype)
9026 
      iprot.readFieldEnd()
9027 
    iprot.readStructEnd()
9028 
 
9029 
  def write(self, oprot):
9030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9032 
      return
3064 chandransh 9033 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9034 
    if self.success is not None:
3064 chandransh 9035 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9036 
      self.success.write(oprot)
94 ashish 9037 
      oprot.writeFieldEnd()
3431 rajveer 9038 
    if self.ex is not None:
94 ashish 9039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9040 
      self.ex.write(oprot)
9041 
      oprot.writeFieldEnd()
9042 
    oprot.writeFieldStop()
9043 
    oprot.writeStructEnd()
9044 
 
3431 rajveer 9045 
  def validate(self):
9046 
    return
9047 
 
9048 
 
94 ashish 9049 
  def __repr__(self):
9050 
    L = ['%s=%r' % (key, value)
9051 
      for key, value in self.__dict__.iteritems()]
9052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9053 
 
9054 
  def __eq__(self, other):
9055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9056 
 
9057 
  def __ne__(self, other):
9058 
    return not (self == other)
9059 
 
3064 chandransh 9060 
class getAlerts_args:
94 ashish 9061 
  """
9062 
  Attributes:
4394 rajveer 9063 
   - type
4444 rajveer 9064 
   - warehouseId
4394 rajveer 9065 
   - status
9066 
   - timestamp
94 ashish 9067 
  """
9068 
 
9069 
  thrift_spec = (
9070 
    None, # 0
4394 rajveer 9071 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9072 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9073 
    (3, TType.I64, 'status', None, None, ), # 3
9074 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9075 
  )
9076 
 
4444 rajveer 9077 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9078 
    self.type = type
4444 rajveer 9079 
    self.warehouseId = warehouseId
4394 rajveer 9080 
    self.status = status
9081 
    self.timestamp = timestamp
94 ashish 9082 
 
9083 
  def read(self, iprot):
9084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9086 
      return
9087 
    iprot.readStructBegin()
9088 
    while True:
9089 
      (fname, ftype, fid) = iprot.readFieldBegin()
9090 
      if ftype == TType.STOP:
9091 
        break
9092 
      if fid == 1:
3064 chandransh 9093 
        if ftype == TType.I64:
4394 rajveer 9094 
          self.type = iprot.readI64();
94 ashish 9095 
        else:
9096 
          iprot.skip(ftype)
3064 chandransh 9097 
      elif fid == 2:
4394 rajveer 9098 
        if ftype == TType.I64:
4444 rajveer 9099 
          self.warehouseId = iprot.readI64();
3064 chandransh 9100 
        else:
9101 
          iprot.skip(ftype)
4394 rajveer 9102 
      elif fid == 3:
9103 
        if ftype == TType.I64:
4444 rajveer 9104 
          self.status = iprot.readI64();
9105 
        else:
9106 
          iprot.skip(ftype)
9107 
      elif fid == 4:
9108 
        if ftype == TType.I64:
4394 rajveer 9109 
          self.timestamp = iprot.readI64();
9110 
        else:
9111 
          iprot.skip(ftype)
94 ashish 9112 
      else:
9113 
        iprot.skip(ftype)
9114 
      iprot.readFieldEnd()
9115 
    iprot.readStructEnd()
9116 
 
9117 
  def write(self, oprot):
9118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9120 
      return
3064 chandransh 9121 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9122 
    if self.type is not None:
9123 
      oprot.writeFieldBegin('type', TType.I64, 1)
9124 
      oprot.writeI64(self.type)
94 ashish 9125 
      oprot.writeFieldEnd()
4444 rajveer 9126 
    if self.warehouseId is not None:
9127 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9128 
      oprot.writeI64(self.warehouseId)
9129 
      oprot.writeFieldEnd()
4394 rajveer 9130 
    if self.status is not None:
4444 rajveer 9131 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9132 
      oprot.writeI64(self.status)
3064 chandransh 9133 
      oprot.writeFieldEnd()
4394 rajveer 9134 
    if self.timestamp is not None:
4444 rajveer 9135 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9136 
      oprot.writeI64(self.timestamp)
9137 
      oprot.writeFieldEnd()
94 ashish 9138 
    oprot.writeFieldStop()
9139 
    oprot.writeStructEnd()
9140 
 
3431 rajveer 9141 
  def validate(self):
9142 
    return
9143 
 
9144 
 
94 ashish 9145 
  def __repr__(self):
9146 
    L = ['%s=%r' % (key, value)
9147 
      for key, value in self.__dict__.iteritems()]
9148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9149 
 
9150 
  def __eq__(self, other):
9151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9152 
 
9153 
  def __ne__(self, other):
9154 
    return not (self == other)
9155 
 
3064 chandransh 9156 
class getAlerts_result:
94 ashish 9157 
  """
9158 
  Attributes:
9159 
   - success
9160 
  """
9161 
 
9162 
  thrift_spec = (
3064 chandransh 9163 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9164 
  )
9165 
 
3064 chandransh 9166 
  def __init__(self, success=None,):
94 ashish 9167 
    self.success = success
9168 
 
9169 
  def read(self, iprot):
9170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9172 
      return
9173 
    iprot.readStructBegin()
9174 
    while True:
9175 
      (fname, ftype, fid) = iprot.readFieldBegin()
9176 
      if ftype == TType.STOP:
9177 
        break
9178 
      if fid == 0:
3064 chandransh 9179 
        if ftype == TType.LIST:
9180 
          self.success = []
4133 chandransh 9181 
          (_etype115, _size112) = iprot.readListBegin()
9182 
          for _i116 in xrange(_size112):
9183 
            _elem117 = Alert()
9184 
            _elem117.read(iprot)
9185 
            self.success.append(_elem117)
3064 chandransh 9186 
          iprot.readListEnd()
94 ashish 9187 
        else:
9188 
          iprot.skip(ftype)
9189 
      else:
9190 
        iprot.skip(ftype)
9191 
      iprot.readFieldEnd()
9192 
    iprot.readStructEnd()
9193 
 
9194 
  def write(self, oprot):
9195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9197 
      return
3064 chandransh 9198 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9199 
    if self.success is not None:
3064 chandransh 9200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9202 
      for iter118 in self.success:
9203 
        iter118.write(oprot)
3064 chandransh 9204 
      oprot.writeListEnd()
94 ashish 9205 
      oprot.writeFieldEnd()
9206 
    oprot.writeFieldStop()
9207 
    oprot.writeStructEnd()
9208 
 
3431 rajveer 9209 
  def validate(self):
9210 
    return
9211 
 
9212 
 
94 ashish 9213 
  def __repr__(self):
9214 
    L = ['%s=%r' % (key, value)
9215 
      for key, value in self.__dict__.iteritems()]
9216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9217 
 
9218 
  def __eq__(self, other):
9219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9220 
 
9221 
  def __ne__(self, other):
9222 
    return not (self == other)
9223 
 
4394 rajveer 9224 
class addAlert_args:
94 ashish 9225 
  """
9226 
  Attributes:
3064 chandransh 9227 
   - type
4444 rajveer 9228 
   - warehouseId
4394 rajveer 9229 
   - description
94 ashish 9230 
  """
9231 
 
9232 
  thrift_spec = (
9233 
    None, # 0
4394 rajveer 9234 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9235 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9236 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9237 
  )
9238 
 
4444 rajveer 9239 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9240 
    self.type = type
4444 rajveer 9241 
    self.warehouseId = warehouseId
4394 rajveer 9242 
    self.description = description
94 ashish 9243 
 
9244 
  def read(self, iprot):
9245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9247 
      return
9248 
    iprot.readStructBegin()
9249 
    while True:
9250 
      (fname, ftype, fid) = iprot.readFieldBegin()
9251 
      if ftype == TType.STOP:
9252 
        break
9253 
      if fid == 1:
9254 
        if ftype == TType.I64:
4394 rajveer 9255 
          self.type = iprot.readI64();
94 ashish 9256 
        else:
9257 
          iprot.skip(ftype)
3064 chandransh 9258 
      elif fid == 2:
4444 rajveer 9259 
        if ftype == TType.I64:
9260 
          self.warehouseId = iprot.readI64();
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      elif fid == 3:
3064 chandransh 9264 
        if ftype == TType.STRING:
4394 rajveer 9265 
          self.description = iprot.readString();
3064 chandransh 9266 
        else:
9267 
          iprot.skip(ftype)
94 ashish 9268 
      else:
9269 
        iprot.skip(ftype)
9270 
      iprot.readFieldEnd()
9271 
    iprot.readStructEnd()
9272 
 
9273 
  def write(self, oprot):
9274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9276 
      return
4394 rajveer 9277 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9278 
    if self.type is not None:
4394 rajveer 9279 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9280 
      oprot.writeI64(self.type)
9281 
      oprot.writeFieldEnd()
4444 rajveer 9282 
    if self.warehouseId is not None:
9283 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9284 
      oprot.writeI64(self.warehouseId)
9285 
      oprot.writeFieldEnd()
4394 rajveer 9286 
    if self.description is not None:
4444 rajveer 9287 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9288 
      oprot.writeString(self.description)
3064 chandransh 9289 
      oprot.writeFieldEnd()
94 ashish 9290 
    oprot.writeFieldStop()
9291 
    oprot.writeStructEnd()
9292 
 
3431 rajveer 9293 
  def validate(self):
9294 
    return
9295 
 
9296 
 
94 ashish 9297 
  def __repr__(self):
9298 
    L = ['%s=%r' % (key, value)
9299 
      for key, value in self.__dict__.iteritems()]
9300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9301 
 
9302 
  def __eq__(self, other):
9303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9304 
 
9305 
  def __ne__(self, other):
9306 
    return not (self == other)
9307 
 
4394 rajveer 9308 
class addAlert_result:
3064 chandransh 9309 
 
9310 
  thrift_spec = (
9311 
  )
9312 
 
9313 
  def read(self, iprot):
9314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9316 
      return
9317 
    iprot.readStructBegin()
9318 
    while True:
9319 
      (fname, ftype, fid) = iprot.readFieldBegin()
9320 
      if ftype == TType.STOP:
9321 
        break
9322 
      else:
9323 
        iprot.skip(ftype)
9324 
      iprot.readFieldEnd()
9325 
    iprot.readStructEnd()
9326 
 
9327 
  def write(self, oprot):
9328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9330 
      return
4394 rajveer 9331 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9332 
    oprot.writeFieldStop()
9333 
    oprot.writeStructEnd()
9334 
 
3431 rajveer 9335 
  def validate(self):
9336 
    return
9337 
 
9338 
 
3064 chandransh 9339 
  def __repr__(self):
9340 
    L = ['%s=%r' % (key, value)
9341 
      for key, value in self.__dict__.iteritems()]
9342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9343 
 
9344 
  def __eq__(self, other):
9345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9346 
 
9347 
  def __ne__(self, other):
9348 
    return not (self == other)
9349 
 
4444 rajveer 9350 
class markAlertsAsSeen_args:
9351 
  """
9352 
  Attributes:
9353 
   - warehouseId
9354 
  """
9355 
 
9356 
  thrift_spec = (
9357 
    None, # 0
9358 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9359 
  )
9360 
 
9361 
  def __init__(self, warehouseId=None,):
9362 
    self.warehouseId = warehouseId
9363 
 
9364 
  def read(self, iprot):
9365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9367 
      return
9368 
    iprot.readStructBegin()
9369 
    while True:
9370 
      (fname, ftype, fid) = iprot.readFieldBegin()
9371 
      if ftype == TType.STOP:
9372 
        break
9373 
      if fid == 1:
9374 
        if ftype == TType.I64:
9375 
          self.warehouseId = iprot.readI64();
9376 
        else:
9377 
          iprot.skip(ftype)
9378 
      else:
9379 
        iprot.skip(ftype)
9380 
      iprot.readFieldEnd()
9381 
    iprot.readStructEnd()
9382 
 
9383 
  def write(self, oprot):
9384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9386 
      return
9387 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9388 
    if self.warehouseId is not None:
9389 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9390 
      oprot.writeI64(self.warehouseId)
9391 
      oprot.writeFieldEnd()
9392 
    oprot.writeFieldStop()
9393 
    oprot.writeStructEnd()
9394 
 
9395 
  def validate(self):
9396 
    return
9397 
 
9398 
 
9399 
  def __repr__(self):
9400 
    L = ['%s=%r' % (key, value)
9401 
      for key, value in self.__dict__.iteritems()]
9402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9403 
 
9404 
  def __eq__(self, other):
9405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9406 
 
9407 
  def __ne__(self, other):
9408 
    return not (self == other)
9409 
 
9410 
class markAlertsAsSeen_result:
9411 
 
9412 
  thrift_spec = (
9413 
  )
9414 
 
9415 
  def read(self, iprot):
9416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9418 
      return
9419 
    iprot.readStructBegin()
9420 
    while True:
9421 
      (fname, ftype, fid) = iprot.readFieldBegin()
9422 
      if ftype == TType.STOP:
9423 
        break
9424 
      else:
9425 
        iprot.skip(ftype)
9426 
      iprot.readFieldEnd()
9427 
    iprot.readStructEnd()
9428 
 
9429 
  def write(self, oprot):
9430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9432 
      return
9433 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9434 
    oprot.writeFieldStop()
9435 
    oprot.writeStructEnd()
9436 
 
9437 
  def validate(self):
9438 
    return
9439 
 
9440 
 
9441 
  def __repr__(self):
9442 
    L = ['%s=%r' % (key, value)
9443 
      for key, value in self.__dict__.iteritems()]
9444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9445 
 
9446 
  def __eq__(self, other):
9447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9448 
 
9449 
  def __ne__(self, other):
9450 
    return not (self == other)
9451 
 
3064 chandransh 9452 
class getValidOrderCount_args:
9453 
 
9454 
  thrift_spec = (
9455 
  )
9456 
 
9457 
  def read(self, iprot):
9458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9460 
      return
9461 
    iprot.readStructBegin()
9462 
    while True:
9463 
      (fname, ftype, fid) = iprot.readFieldBegin()
9464 
      if ftype == TType.STOP:
9465 
        break
9466 
      else:
9467 
        iprot.skip(ftype)
9468 
      iprot.readFieldEnd()
9469 
    iprot.readStructEnd()
9470 
 
9471 
  def write(self, oprot):
9472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9474 
      return
9475 
    oprot.writeStructBegin('getValidOrderCount_args')
9476 
    oprot.writeFieldStop()
9477 
    oprot.writeStructEnd()
9478 
 
3431 rajveer 9479 
  def validate(self):
9480 
    return
9481 
 
9482 
 
3064 chandransh 9483 
  def __repr__(self):
9484 
    L = ['%s=%r' % (key, value)
9485 
      for key, value in self.__dict__.iteritems()]
9486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9487 
 
9488 
  def __eq__(self, other):
9489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9490 
 
9491 
  def __ne__(self, other):
9492 
    return not (self == other)
9493 
 
9494 
class getValidOrderCount_result:
94 ashish 9495 
  """
9496 
  Attributes:
9497 
   - success
9498 
  """
9499 
 
9500 
  thrift_spec = (
3064 chandransh 9501 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9502 
  )
9503 
 
3064 chandransh 9504 
  def __init__(self, success=None,):
94 ashish 9505 
    self.success = success
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 
      if fid == 0:
3064 chandransh 9517 
        if ftype == TType.I64:
9518 
          self.success = iprot.readI64();
94 ashish 9519 
        else:
9520 
          iprot.skip(ftype)
9521 
      else:
9522 
        iprot.skip(ftype)
9523 
      iprot.readFieldEnd()
9524 
    iprot.readStructEnd()
9525 
 
9526 
  def write(self, oprot):
9527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9529 
      return
3064 chandransh 9530 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9531 
    if self.success is not None:
3064 chandransh 9532 
      oprot.writeFieldBegin('success', TType.I64, 0)
9533 
      oprot.writeI64(self.success)
94 ashish 9534 
      oprot.writeFieldEnd()
9535 
    oprot.writeFieldStop()
9536 
    oprot.writeStructEnd()
9537 
 
3431 rajveer 9538 
  def validate(self):
9539 
    return
9540 
 
9541 
 
94 ashish 9542 
  def __repr__(self):
9543 
    L = ['%s=%r' % (key, value)
9544 
      for key, value in self.__dict__.iteritems()]
9545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9546 
 
9547 
  def __eq__(self, other):
9548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9549 
 
9550 
  def __ne__(self, other):
9551 
    return not (self == other)
9552 
 
3064 chandransh 9553 
class getNoOfCustomersWithSuccessfulTransaction_args:
9554 
 
9555 
  thrift_spec = (
9556 
  )
9557 
 
9558 
  def read(self, iprot):
9559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9561 
      return
9562 
    iprot.readStructBegin()
9563 
    while True:
9564 
      (fname, ftype, fid) = iprot.readFieldBegin()
9565 
      if ftype == TType.STOP:
9566 
        break
9567 
      else:
9568 
        iprot.skip(ftype)
9569 
      iprot.readFieldEnd()
9570 
    iprot.readStructEnd()
9571 
 
9572 
  def write(self, oprot):
9573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9575 
      return
9576 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9577 
    oprot.writeFieldStop()
9578 
    oprot.writeStructEnd()
9579 
 
3431 rajveer 9580 
  def validate(self):
9581 
    return
9582 
 
9583 
 
3064 chandransh 9584 
  def __repr__(self):
9585 
    L = ['%s=%r' % (key, value)
9586 
      for key, value in self.__dict__.iteritems()]
9587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9588 
 
9589 
  def __eq__(self, other):
9590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9591 
 
9592 
  def __ne__(self, other):
9593 
    return not (self == other)
9594 
 
9595 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9596 
  """
9597 
  Attributes:
3064 chandransh 9598 
   - success
94 ashish 9599 
  """
9600 
 
9601 
  thrift_spec = (
3064 chandransh 9602 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9603 
  )
9604 
 
3064 chandransh 9605 
  def __init__(self, success=None,):
9606 
    self.success = success
94 ashish 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
3064 chandransh 9617 
      if fid == 0:
94 ashish 9618 
        if ftype == TType.I64:
3064 chandransh 9619 
          self.success = iprot.readI64();
94 ashish 9620 
        else:
9621 
          iprot.skip(ftype)
9622 
      else:
9623 
        iprot.skip(ftype)
9624 
      iprot.readFieldEnd()
9625 
    iprot.readStructEnd()
9626 
 
9627 
  def write(self, oprot):
9628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9630 
      return
3064 chandransh 9631 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9632 
    if self.success is not None:
3064 chandransh 9633 
      oprot.writeFieldBegin('success', TType.I64, 0)
9634 
      oprot.writeI64(self.success)
94 ashish 9635 
      oprot.writeFieldEnd()
9636 
    oprot.writeFieldStop()
9637 
    oprot.writeStructEnd()
9638 
 
3431 rajveer 9639 
  def validate(self):
9640 
    return
9641 
 
9642 
 
94 ashish 9643 
  def __repr__(self):
9644 
    L = ['%s=%r' % (key, value)
9645 
      for key, value in self.__dict__.iteritems()]
9646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9647 
 
9648 
  def __eq__(self, other):
9649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9650 
 
9651 
  def __ne__(self, other):
9652 
    return not (self == other)
9653 
 
3064 chandransh 9654 
class getValidOrdersAmountRange_args:
9655 
 
9656 
  thrift_spec = (
9657 
  )
9658 
 
9659 
  def read(self, iprot):
9660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9662 
      return
9663 
    iprot.readStructBegin()
9664 
    while True:
9665 
      (fname, ftype, fid) = iprot.readFieldBegin()
9666 
      if ftype == TType.STOP:
9667 
        break
9668 
      else:
9669 
        iprot.skip(ftype)
9670 
      iprot.readFieldEnd()
9671 
    iprot.readStructEnd()
9672 
 
9673 
  def write(self, oprot):
9674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9676 
      return
9677 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9678 
    oprot.writeFieldStop()
9679 
    oprot.writeStructEnd()
9680 
 
3431 rajveer 9681 
  def validate(self):
9682 
    return
9683 
 
9684 
 
3064 chandransh 9685 
  def __repr__(self):
9686 
    L = ['%s=%r' % (key, value)
9687 
      for key, value in self.__dict__.iteritems()]
9688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9689 
 
9690 
  def __eq__(self, other):
9691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9692 
 
9693 
  def __ne__(self, other):
9694 
    return not (self == other)
9695 
 
9696 
class getValidOrdersAmountRange_result:
94 ashish 9697 
  """
9698 
  Attributes:
9699 
   - success
9700 
  """
9701 
 
9702 
  thrift_spec = (
3064 chandransh 9703 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9704 
  )
9705 
 
3064 chandransh 9706 
  def __init__(self, success=None,):
94 ashish 9707 
    self.success = success
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 
      if fid == 0:
483 rajveer 9719 
        if ftype == TType.LIST:
9720 
          self.success = []
4133 chandransh 9721 
          (_etype122, _size119) = iprot.readListBegin()
9722 
          for _i123 in xrange(_size119):
9723 
            _elem124 = iprot.readDouble();
9724 
            self.success.append(_elem124)
483 rajveer 9725 
          iprot.readListEnd()
94 ashish 9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      else:
9729 
        iprot.skip(ftype)
9730 
      iprot.readFieldEnd()
9731 
    iprot.readStructEnd()
9732 
 
9733 
  def write(self, oprot):
9734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9736 
      return
3064 chandransh 9737 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9738 
    if self.success is not None:
483 rajveer 9739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9740 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9741 
      for iter125 in self.success:
9742 
        oprot.writeDouble(iter125)
483 rajveer 9743 
      oprot.writeListEnd()
94 ashish 9744 
      oprot.writeFieldEnd()
9745 
    oprot.writeFieldStop()
9746 
    oprot.writeStructEnd()
9747 
 
3431 rajveer 9748 
  def validate(self):
9749 
    return
9750 
 
9751 
 
94 ashish 9752 
  def __repr__(self):
9753 
    L = ['%s=%r' % (key, value)
9754 
      for key, value in self.__dict__.iteritems()]
9755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9756 
 
9757 
  def __eq__(self, other):
9758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9759 
 
9760 
  def __ne__(self, other):
9761 
    return not (self == other)
9762 
 
3064 chandransh 9763 
class getValidOrders_args:
1528 ankur.sing 9764 
  """
9765 
  Attributes:
3064 chandransh 9766 
   - limit
1528 ankur.sing 9767 
  """
9768 
 
9769 
  thrift_spec = (
9770 
    None, # 0
3064 chandransh 9771 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9772 
  )
9773 
 
3064 chandransh 9774 
  def __init__(self, limit=None,):
9775 
    self.limit = limit
1528 ankur.sing 9776 
 
9777 
  def read(self, iprot):
9778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9780 
      return
9781 
    iprot.readStructBegin()
9782 
    while True:
9783 
      (fname, ftype, fid) = iprot.readFieldBegin()
9784 
      if ftype == TType.STOP:
9785 
        break
9786 
      if fid == 1:
9787 
        if ftype == TType.I64:
3064 chandransh 9788 
          self.limit = iprot.readI64();
1528 ankur.sing 9789 
        else:
9790 
          iprot.skip(ftype)
9791 
      else:
9792 
        iprot.skip(ftype)
9793 
      iprot.readFieldEnd()
9794 
    iprot.readStructEnd()
9795 
 
9796 
  def write(self, oprot):
9797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9799 
      return
3064 chandransh 9800 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9801 
    if self.limit is not None:
3064 chandransh 9802 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9803 
      oprot.writeI64(self.limit)
1528 ankur.sing 9804 
      oprot.writeFieldEnd()
9805 
    oprot.writeFieldStop()
9806 
    oprot.writeStructEnd()
9807 
 
3431 rajveer 9808 
  def validate(self):
9809 
    return
9810 
 
9811 
 
1528 ankur.sing 9812 
  def __repr__(self):
9813 
    L = ['%s=%r' % (key, value)
9814 
      for key, value in self.__dict__.iteritems()]
9815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9816 
 
9817 
  def __eq__(self, other):
9818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9819 
 
9820 
  def __ne__(self, other):
9821 
    return not (self == other)
9822 
 
3064 chandransh 9823 
class getValidOrders_result:
1528 ankur.sing 9824 
  """
9825 
  Attributes:
9826 
   - success
9827 
  """
9828 
 
9829 
  thrift_spec = (
3064 chandransh 9830 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9831 
  )
9832 
 
3064 chandransh 9833 
  def __init__(self, success=None,):
1528 ankur.sing 9834 
    self.success = success
9835 
 
9836 
  def read(self, iprot):
9837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9839 
      return
9840 
    iprot.readStructBegin()
9841 
    while True:
9842 
      (fname, ftype, fid) = iprot.readFieldBegin()
9843 
      if ftype == TType.STOP:
9844 
        break
9845 
      if fid == 0:
3064 chandransh 9846 
        if ftype == TType.LIST:
9847 
          self.success = []
4133 chandransh 9848 
          (_etype129, _size126) = iprot.readListBegin()
9849 
          for _i130 in xrange(_size126):
9850 
            _elem131 = Order()
9851 
            _elem131.read(iprot)
9852 
            self.success.append(_elem131)
3064 chandransh 9853 
          iprot.readListEnd()
1528 ankur.sing 9854 
        else:
9855 
          iprot.skip(ftype)
9856 
      else:
9857 
        iprot.skip(ftype)
9858 
      iprot.readFieldEnd()
9859 
    iprot.readStructEnd()
9860 
 
9861 
  def write(self, oprot):
9862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9864 
      return
3064 chandransh 9865 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9866 
    if self.success is not None:
3064 chandransh 9867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9869 
      for iter132 in self.success:
9870 
        iter132.write(oprot)
3064 chandransh 9871 
      oprot.writeListEnd()
1528 ankur.sing 9872 
      oprot.writeFieldEnd()
9873 
    oprot.writeFieldStop()
9874 
    oprot.writeStructEnd()
9875 
 
3431 rajveer 9876 
  def validate(self):
9877 
    return
9878 
 
9879 
 
1528 ankur.sing 9880 
  def __repr__(self):
9881 
    L = ['%s=%r' % (key, value)
9882 
      for key, value in self.__dict__.iteritems()]
9883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9884 
 
9885 
  def __eq__(self, other):
9886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9887 
 
9888 
  def __ne__(self, other):
9889 
    return not (self == other)
9890 
 
1220 chandransh 9891 
class batchOrders_args:
9892 
  """
9893 
  Attributes:
9894 
   - warehouseId
9895 
  """
9896 
 
9897 
  thrift_spec = (
9898 
    None, # 0
9899 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9900 
  )
9901 
 
9902 
  def __init__(self, warehouseId=None,):
9903 
    self.warehouseId = warehouseId
9904 
 
9905 
  def read(self, iprot):
9906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9908 
      return
9909 
    iprot.readStructBegin()
9910 
    while True:
9911 
      (fname, ftype, fid) = iprot.readFieldBegin()
9912 
      if ftype == TType.STOP:
9913 
        break
9914 
      if fid == 1:
9915 
        if ftype == TType.I64:
9916 
          self.warehouseId = iprot.readI64();
9917 
        else:
9918 
          iprot.skip(ftype)
9919 
      else:
9920 
        iprot.skip(ftype)
9921 
      iprot.readFieldEnd()
9922 
    iprot.readStructEnd()
9923 
 
9924 
  def write(self, oprot):
9925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9927 
      return
9928 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9929 
    if self.warehouseId is not None:
1220 chandransh 9930 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9931 
      oprot.writeI64(self.warehouseId)
9932 
      oprot.writeFieldEnd()
9933 
    oprot.writeFieldStop()
9934 
    oprot.writeStructEnd()
9935 
 
3431 rajveer 9936 
  def validate(self):
9937 
    return
9938 
 
9939 
 
1220 chandransh 9940 
  def __repr__(self):
9941 
    L = ['%s=%r' % (key, value)
9942 
      for key, value in self.__dict__.iteritems()]
9943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9944 
 
9945 
  def __eq__(self, other):
9946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9947 
 
9948 
  def __ne__(self, other):
9949 
    return not (self == other)
9950 
 
9951 
class batchOrders_result:
9952 
  """
9953 
  Attributes:
9954 
   - success
9955 
   - ex
9956 
  """
9957 
 
9958 
  thrift_spec = (
9959 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9961 
  )
9962 
 
9963 
  def __init__(self, success=None, ex=None,):
9964 
    self.success = success
9965 
    self.ex = ex
9966 
 
9967 
  def read(self, iprot):
9968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9970 
      return
9971 
    iprot.readStructBegin()
9972 
    while True:
9973 
      (fname, ftype, fid) = iprot.readFieldBegin()
9974 
      if ftype == TType.STOP:
9975 
        break
9976 
      if fid == 0:
9977 
        if ftype == TType.LIST:
9978 
          self.success = []
4133 chandransh 9979 
          (_etype136, _size133) = iprot.readListBegin()
9980 
          for _i137 in xrange(_size133):
9981 
            _elem138 = Order()
9982 
            _elem138.read(iprot)
9983 
            self.success.append(_elem138)
1220 chandransh 9984 
          iprot.readListEnd()
9985 
        else:
9986 
          iprot.skip(ftype)
9987 
      elif fid == 1:
9988 
        if ftype == TType.STRUCT:
9989 
          self.ex = TransactionServiceException()
9990 
          self.ex.read(iprot)
9991 
        else:
9992 
          iprot.skip(ftype)
9993 
      else:
9994 
        iprot.skip(ftype)
9995 
      iprot.readFieldEnd()
9996 
    iprot.readStructEnd()
9997 
 
9998 
  def write(self, oprot):
9999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10001 
      return
10002 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10003 
    if self.success is not None:
1220 chandransh 10004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10006 
      for iter139 in self.success:
10007 
        iter139.write(oprot)
1220 chandransh 10008 
      oprot.writeListEnd()
10009 
      oprot.writeFieldEnd()
3431 rajveer 10010 
    if self.ex is not None:
1220 chandransh 10011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10012 
      self.ex.write(oprot)
10013 
      oprot.writeFieldEnd()
10014 
    oprot.writeFieldStop()
10015 
    oprot.writeStructEnd()
10016 
 
3431 rajveer 10017 
  def validate(self):
10018 
    return
10019 
 
10020 
 
1220 chandransh 10021 
  def __repr__(self):
10022 
    L = ['%s=%r' % (key, value)
10023 
      for key, value in self.__dict__.iteritems()]
10024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10025 
 
10026 
  def __eq__(self, other):
10027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10028 
 
10029 
  def __ne__(self, other):
10030 
    return not (self == other)
10031 
 
1208 chandransh 10032 
class markOrderAsOutOfStock_args:
10033 
  """
10034 
  Attributes:
10035 
   - orderId
10036 
  """
10037 
 
10038 
  thrift_spec = (
10039 
    None, # 0
10040 
    (1, TType.I64, 'orderId', None, None, ), # 1
10041 
  )
10042 
 
10043 
  def __init__(self, orderId=None,):
10044 
    self.orderId = orderId
10045 
 
10046 
  def read(self, iprot):
10047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10049 
      return
10050 
    iprot.readStructBegin()
10051 
    while True:
10052 
      (fname, ftype, fid) = iprot.readFieldBegin()
10053 
      if ftype == TType.STOP:
10054 
        break
10055 
      if fid == 1:
10056 
        if ftype == TType.I64:
10057 
          self.orderId = iprot.readI64();
10058 
        else:
10059 
          iprot.skip(ftype)
10060 
      else:
10061 
        iprot.skip(ftype)
10062 
      iprot.readFieldEnd()
10063 
    iprot.readStructEnd()
10064 
 
10065 
  def write(self, oprot):
10066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10068 
      return
10069 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10070 
    if self.orderId is not None:
1208 chandransh 10071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10072 
      oprot.writeI64(self.orderId)
10073 
      oprot.writeFieldEnd()
10074 
    oprot.writeFieldStop()
10075 
    oprot.writeStructEnd()
10076 
 
3431 rajveer 10077 
  def validate(self):
10078 
    return
10079 
 
10080 
 
1208 chandransh 10081 
  def __repr__(self):
10082 
    L = ['%s=%r' % (key, value)
10083 
      for key, value in self.__dict__.iteritems()]
10084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10085 
 
10086 
  def __eq__(self, other):
10087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10088 
 
10089 
  def __ne__(self, other):
10090 
    return not (self == other)
10091 
 
10092 
class markOrderAsOutOfStock_result:
10093 
  """
10094 
  Attributes:
10095 
   - success
10096 
   - ex
10097 
  """
10098 
 
10099 
  thrift_spec = (
10100 
    (0, TType.BOOL, 'success', None, None, ), # 0
10101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10102 
  )
10103 
 
10104 
  def __init__(self, success=None, ex=None,):
10105 
    self.success = success
10106 
    self.ex = ex
10107 
 
10108 
  def read(self, iprot):
10109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10111 
      return
10112 
    iprot.readStructBegin()
10113 
    while True:
10114 
      (fname, ftype, fid) = iprot.readFieldBegin()
10115 
      if ftype == TType.STOP:
10116 
        break
10117 
      if fid == 0:
10118 
        if ftype == TType.BOOL:
10119 
          self.success = iprot.readBool();
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      elif fid == 1:
10123 
        if ftype == TType.STRUCT:
10124 
          self.ex = TransactionServiceException()
10125 
          self.ex.read(iprot)
10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      else:
10129 
        iprot.skip(ftype)
10130 
      iprot.readFieldEnd()
10131 
    iprot.readStructEnd()
10132 
 
10133 
  def write(self, oprot):
10134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10136 
      return
10137 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10138 
    if self.success is not None:
1208 chandransh 10139 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10140 
      oprot.writeBool(self.success)
10141 
      oprot.writeFieldEnd()
3431 rajveer 10142 
    if self.ex is not None:
1208 chandransh 10143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10144 
      self.ex.write(oprot)
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
1208 chandransh 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
3064 chandransh 10164 
class verifyOrder_args:
759 chandransh 10165 
  """
10166 
  Attributes:
3064 chandransh 10167 
   - orderId
759 chandransh 10168 
  """
10169 
 
10170 
  thrift_spec = (
10171 
    None, # 0
3064 chandransh 10172 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10173 
  )
10174 
 
3064 chandransh 10175 
  def __init__(self, orderId=None,):
10176 
    self.orderId = orderId
759 chandransh 10177 
 
10178 
  def read(self, iprot):
10179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10181 
      return
10182 
    iprot.readStructBegin()
10183 
    while True:
10184 
      (fname, ftype, fid) = iprot.readFieldBegin()
10185 
      if ftype == TType.STOP:
10186 
        break
10187 
      if fid == 1:
10188 
        if ftype == TType.I64:
3064 chandransh 10189 
          self.orderId = iprot.readI64();
759 chandransh 10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
3064 chandransh 10201 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10202 
    if self.orderId is not None:
3064 chandransh 10203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10204 
      oprot.writeI64(self.orderId)
759 chandransh 10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
3431 rajveer 10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
759 chandransh 10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
3064 chandransh 10224 
class verifyOrder_result:
759 chandransh 10225 
  """
10226 
  Attributes:
10227 
   - success
10228 
   - ex
10229 
  """
10230 
 
10231 
  thrift_spec = (
10232 
    (0, TType.BOOL, 'success', None, None, ), # 0
10233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10234 
  )
10235 
 
10236 
  def __init__(self, success=None, ex=None,):
10237 
    self.success = success
10238 
    self.ex = ex
10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 0:
10250 
        if ftype == TType.BOOL:
10251 
          self.success = iprot.readBool();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 1:
10255 
        if ftype == TType.STRUCT:
10256 
          self.ex = TransactionServiceException()
10257 
          self.ex.read(iprot)
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
3064 chandransh 10269 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10270 
    if self.success is not None:
759 chandransh 10271 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10272 
      oprot.writeBool(self.success)
10273 
      oprot.writeFieldEnd()
3431 rajveer 10274 
    if self.ex is not None:
759 chandransh 10275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10276 
      self.ex.write(oprot)
10277 
      oprot.writeFieldEnd()
10278 
    oprot.writeFieldStop()
10279 
    oprot.writeStructEnd()
10280 
 
3431 rajveer 10281 
  def validate(self):
10282 
    return
10283 
 
10284 
 
759 chandransh 10285 
  def __repr__(self):
10286 
    L = ['%s=%r' % (key, value)
10287 
      for key, value in self.__dict__.iteritems()]
10288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10289 
 
10290 
  def __eq__(self, other):
10291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10292 
 
10293 
  def __ne__(self, other):
10294 
    return not (self == other)
10295 
 
3064 chandransh 10296 
class acceptOrder_args:
1113 chandransh 10297 
  """
10298 
  Attributes:
3064 chandransh 10299 
   - orderId
1113 chandransh 10300 
  """
10301 
 
10302 
  thrift_spec = (
10303 
    None, # 0
3064 chandransh 10304 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10305 
  )
10306 
 
3064 chandransh 10307 
  def __init__(self, orderId=None,):
10308 
    self.orderId = orderId
1113 chandransh 10309 
 
10310 
  def read(self, iprot):
10311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10313 
      return
10314 
    iprot.readStructBegin()
10315 
    while True:
10316 
      (fname, ftype, fid) = iprot.readFieldBegin()
10317 
      if ftype == TType.STOP:
10318 
        break
10319 
      if fid == 1:
10320 
        if ftype == TType.I64:
3064 chandransh 10321 
          self.orderId = iprot.readI64();
1113 chandransh 10322 
        else:
10323 
          iprot.skip(ftype)
10324 
      else:
10325 
        iprot.skip(ftype)
10326 
      iprot.readFieldEnd()
10327 
    iprot.readStructEnd()
10328 
 
10329 
  def write(self, oprot):
10330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10332 
      return
3064 chandransh 10333 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10334 
    if self.orderId is not None:
3064 chandransh 10335 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10336 
      oprot.writeI64(self.orderId)
1113 chandransh 10337 
      oprot.writeFieldEnd()
10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
3431 rajveer 10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
1113 chandransh 10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
3064 chandransh 10356 
class acceptOrder_result:
1113 chandransh 10357 
  """
10358 
  Attributes:
10359 
   - success
10360 
   - ex
10361 
  """
10362 
 
10363 
  thrift_spec = (
3064 chandransh 10364 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10366 
  )
10367 
 
10368 
  def __init__(self, success=None, ex=None,):
10369 
    self.success = success
10370 
    self.ex = ex
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 0:
3064 chandransh 10382 
        if ftype == TType.BOOL:
10383 
          self.success = iprot.readBool();
1113 chandransh 10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      elif fid == 1:
10387 
        if ftype == TType.STRUCT:
10388 
          self.ex = TransactionServiceException()
10389 
          self.ex.read(iprot)
10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
3064 chandransh 10401 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10402 
    if self.success is not None:
3064 chandransh 10403 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10404 
      oprot.writeBool(self.success)
1113 chandransh 10405 
      oprot.writeFieldEnd()
3431 rajveer 10406 
    if self.ex is not None:
1113 chandransh 10407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10408 
      self.ex.write(oprot)
10409 
      oprot.writeFieldEnd()
10410 
    oprot.writeFieldStop()
10411 
    oprot.writeStructEnd()
10412 
 
3431 rajveer 10413 
  def validate(self):
10414 
    return
10415 
 
10416 
 
1113 chandransh 10417 
  def __repr__(self):
10418 
    L = ['%s=%r' % (key, value)
10419 
      for key, value in self.__dict__.iteritems()]
10420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10421 
 
10422 
  def __eq__(self, other):
10423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10424 
 
10425 
  def __ne__(self, other):
10426 
    return not (self == other)
10427 
 
3064 chandransh 10428 
class addBillingDetails_args:
1135 chandransh 10429 
  """
10430 
  Attributes:
3064 chandransh 10431 
   - orderId
10432 
   - invoice_number
4658 mandeep.dh 10433 
   - serialNumber
4283 anupam.sin 10434 
   - itemNumber
3064 chandransh 10435 
   - billed_by
4264 rajveer 10436 
   - jacketNumber
4283 anupam.sin 10437 
   - billingType
10438 
   - vendorId
4763 rajveer 10439 
   - authorize
1135 chandransh 10440 
  """
10441 
 
10442 
  thrift_spec = (
10443 
    None, # 0
3064 chandransh 10444 
    (1, TType.I64, 'orderId', None, None, ), # 1
10445 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10446 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10447 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10448 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10449 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10450 
    (7, TType.I64, 'billingType', None, None, ), # 7
10451 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10452 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10453 
  )
10454 
 
4763 rajveer 10455 
  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 10456 
    self.orderId = orderId
10457 
    self.invoice_number = invoice_number
4658 mandeep.dh 10458 
    self.serialNumber = serialNumber
4283 anupam.sin 10459 
    self.itemNumber = itemNumber
3064 chandransh 10460 
    self.billed_by = billed_by
4264 rajveer 10461 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10462 
    self.billingType = billingType
10463 
    self.vendorId = vendorId
4763 rajveer 10464 
    self.authorize = authorize
1135 chandransh 10465 
 
10466 
  def read(self, iprot):
10467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10469 
      return
10470 
    iprot.readStructBegin()
10471 
    while True:
10472 
      (fname, ftype, fid) = iprot.readFieldBegin()
10473 
      if ftype == TType.STOP:
10474 
        break
10475 
      if fid == 1:
10476 
        if ftype == TType.I64:
3064 chandransh 10477 
          self.orderId = iprot.readI64();
1135 chandransh 10478 
        else:
10479 
          iprot.skip(ftype)
10480 
      elif fid == 2:
3064 chandransh 10481 
        if ftype == TType.STRING:
10482 
          self.invoice_number = iprot.readString();
1135 chandransh 10483 
        else:
10484 
          iprot.skip(ftype)
3064 chandransh 10485 
      elif fid == 3:
4658 mandeep.dh 10486 
        if ftype == TType.STRING:
10487 
          self.serialNumber = iprot.readString();
3064 chandransh 10488 
        else:
10489 
          iprot.skip(ftype)
10490 
      elif fid == 4:
10491 
        if ftype == TType.STRING:
10492 
          self.itemNumber = iprot.readString();
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      elif fid == 5:
10496 
        if ftype == TType.STRING:
4283 anupam.sin 10497 
          self.billed_by = iprot.readString();
3064 chandransh 10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      elif fid == 6:
10501 
        if ftype == TType.I64:
4283 anupam.sin 10502 
          self.jacketNumber = iprot.readI64();
10503 
        else:
10504 
          iprot.skip(ftype)
10505 
      elif fid == 7:
10506 
        if ftype == TType.I64:
3064 chandransh 10507 
          self.billingType = iprot.readI64();
10508 
        else:
10509 
          iprot.skip(ftype)
4283 anupam.sin 10510 
      elif fid == 8:
10511 
        if ftype == TType.I64:
10512 
          self.vendorId = iprot.readI64();
10513 
        else:
10514 
          iprot.skip(ftype)
4763 rajveer 10515 
      elif fid == 9:
10516 
        if ftype == TType.BOOL:
10517 
          self.authorize = iprot.readBool();
10518 
        else:
10519 
          iprot.skip(ftype)
1246 chandransh 10520 
      else:
10521 
        iprot.skip(ftype)
10522 
      iprot.readFieldEnd()
10523 
    iprot.readStructEnd()
10524 
 
10525 
  def write(self, oprot):
10526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10528 
      return
4283 anupam.sin 10529 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10530 
    if self.orderId is not None:
3064 chandransh 10531 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10532 
      oprot.writeI64(self.orderId)
1246 chandransh 10533 
      oprot.writeFieldEnd()
4283 anupam.sin 10534 
    if self.invoice_number is not None:
10535 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10536 
      oprot.writeString(self.invoice_number)
1246 chandransh 10537 
      oprot.writeFieldEnd()
4658 mandeep.dh 10538 
    if self.serialNumber is not None:
10539 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10540 
      oprot.writeString(self.serialNumber)
3064 chandransh 10541 
      oprot.writeFieldEnd()
3431 rajveer 10542 
    if self.itemNumber is not None:
3064 chandransh 10543 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10544 
      oprot.writeString(self.itemNumber)
10545 
      oprot.writeFieldEnd()
4283 anupam.sin 10546 
    if self.billed_by is not None:
10547 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10548 
      oprot.writeString(self.billed_by)
3064 chandransh 10549 
      oprot.writeFieldEnd()
4283 anupam.sin 10550 
    if self.jacketNumber is not None:
10551 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10552 
      oprot.writeI64(self.jacketNumber)
10553 
      oprot.writeFieldEnd()
3431 rajveer 10554 
    if self.billingType is not None:
4283 anupam.sin 10555 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10556 
      oprot.writeI64(self.billingType)
10557 
      oprot.writeFieldEnd()
4283 anupam.sin 10558 
    if self.vendorId is not None:
10559 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10560 
      oprot.writeI64(self.vendorId)
10561 
      oprot.writeFieldEnd()
4763 rajveer 10562 
    if self.authorize is not None:
10563 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10564 
      oprot.writeBool(self.authorize)
10565 
      oprot.writeFieldEnd()
1246 chandransh 10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
3431 rajveer 10569 
  def validate(self):
10570 
    return
10571 
 
10572 
 
1246 chandransh 10573 
  def __repr__(self):
10574 
    L = ['%s=%r' % (key, value)
10575 
      for key, value in self.__dict__.iteritems()]
10576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10577 
 
10578 
  def __eq__(self, other):
10579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10580 
 
10581 
  def __ne__(self, other):
10582 
    return not (self == other)
10583 
 
4283 anupam.sin 10584 
class addBillingDetails_result:
1246 chandransh 10585 
  """
10586 
  Attributes:
3064 chandransh 10587 
   - success
1246 chandransh 10588 
   - ex
10589 
  """
10590 
 
10591 
  thrift_spec = (
3064 chandransh 10592 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10594 
  )
10595 
 
3064 chandransh 10596 
  def __init__(self, success=None, ex=None,):
10597 
    self.success = success
1246 chandransh 10598 
    self.ex = ex
10599 
 
10600 
  def read(self, iprot):
10601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10603 
      return
10604 
    iprot.readStructBegin()
10605 
    while True:
10606 
      (fname, ftype, fid) = iprot.readFieldBegin()
10607 
      if ftype == TType.STOP:
10608 
        break
3064 chandransh 10609 
      if fid == 0:
10610 
        if ftype == TType.BOOL:
10611 
          self.success = iprot.readBool();
10612 
        else:
10613 
          iprot.skip(ftype)
10614 
      elif fid == 1:
1246 chandransh 10615 
        if ftype == TType.STRUCT:
10616 
          self.ex = TransactionServiceException()
10617 
          self.ex.read(iprot)
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      else:
10621 
        iprot.skip(ftype)
10622 
      iprot.readFieldEnd()
10623 
    iprot.readStructEnd()
10624 
 
10625 
  def write(self, oprot):
10626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10628 
      return
4283 anupam.sin 10629 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10630 
    if self.success is not None:
3064 chandransh 10631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10632 
      oprot.writeBool(self.success)
10633 
      oprot.writeFieldEnd()
3431 rajveer 10634 
    if self.ex is not None:
1246 chandransh 10635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10636 
      self.ex.write(oprot)
10637 
      oprot.writeFieldEnd()
10638 
    oprot.writeFieldStop()
10639 
    oprot.writeStructEnd()
10640 
 
3431 rajveer 10641 
  def validate(self):
10642 
    return
10643 
 
10644 
 
1246 chandransh 10645 
  def __repr__(self):
10646 
    L = ['%s=%r' % (key, value)
10647 
      for key, value in self.__dict__.iteritems()]
10648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10649 
 
10650 
  def __eq__(self, other):
10651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10652 
 
10653 
  def __ne__(self, other):
10654 
    return not (self == other)
10655 
 
4579 rajveer 10656 
class addInvoiceNumber_args:
10657 
  """
10658 
  Attributes:
10659 
   - orderId
10660 
   - invoiceNumber
4763 rajveer 10661 
   - color
4579 rajveer 10662 
  """
10663 
 
10664 
  thrift_spec = (
10665 
    None, # 0
10666 
    (1, TType.I64, 'orderId', None, None, ), # 1
10667 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10668 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10669 
  )
10670 
 
4763 rajveer 10671 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10672 
    self.orderId = orderId
10673 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10674 
    self.color = color
4579 rajveer 10675 
 
10676 
  def read(self, iprot):
10677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10679 
      return
10680 
    iprot.readStructBegin()
10681 
    while True:
10682 
      (fname, ftype, fid) = iprot.readFieldBegin()
10683 
      if ftype == TType.STOP:
10684 
        break
10685 
      if fid == 1:
10686 
        if ftype == TType.I64:
10687 
          self.orderId = iprot.readI64();
10688 
        else:
10689 
          iprot.skip(ftype)
10690 
      elif fid == 2:
10691 
        if ftype == TType.STRING:
10692 
          self.invoiceNumber = iprot.readString();
10693 
        else:
10694 
          iprot.skip(ftype)
4763 rajveer 10695 
      elif fid == 3:
10696 
        if ftype == TType.STRING:
10697 
          self.color = iprot.readString();
10698 
        else:
10699 
          iprot.skip(ftype)
4579 rajveer 10700 
      else:
10701 
        iprot.skip(ftype)
10702 
      iprot.readFieldEnd()
10703 
    iprot.readStructEnd()
10704 
 
10705 
  def write(self, oprot):
10706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10708 
      return
10709 
    oprot.writeStructBegin('addInvoiceNumber_args')
10710 
    if self.orderId is not None:
10711 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10712 
      oprot.writeI64(self.orderId)
10713 
      oprot.writeFieldEnd()
10714 
    if self.invoiceNumber is not None:
10715 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10716 
      oprot.writeString(self.invoiceNumber)
10717 
      oprot.writeFieldEnd()
4763 rajveer 10718 
    if self.color is not None:
10719 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10720 
      oprot.writeString(self.color)
10721 
      oprot.writeFieldEnd()
4579 rajveer 10722 
    oprot.writeFieldStop()
10723 
    oprot.writeStructEnd()
10724 
 
10725 
  def validate(self):
10726 
    return
10727 
 
10728 
 
10729 
  def __repr__(self):
10730 
    L = ['%s=%r' % (key, value)
10731 
      for key, value in self.__dict__.iteritems()]
10732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10733 
 
10734 
  def __eq__(self, other):
10735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10736 
 
10737 
  def __ne__(self, other):
10738 
    return not (self == other)
10739 
 
10740 
class addInvoiceNumber_result:
10741 
  """
10742 
  Attributes:
10743 
   - ex
10744 
  """
10745 
 
10746 
  thrift_spec = (
10747 
    None, # 0
10748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10749 
  )
10750 
 
10751 
  def __init__(self, ex=None,):
10752 
    self.ex = ex
10753 
 
10754 
  def read(self, iprot):
10755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10757 
      return
10758 
    iprot.readStructBegin()
10759 
    while True:
10760 
      (fname, ftype, fid) = iprot.readFieldBegin()
10761 
      if ftype == TType.STOP:
10762 
        break
10763 
      if fid == 1:
10764 
        if ftype == TType.STRUCT:
10765 
          self.ex = TransactionServiceException()
10766 
          self.ex.read(iprot)
10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      else:
10770 
        iprot.skip(ftype)
10771 
      iprot.readFieldEnd()
10772 
    iprot.readStructEnd()
10773 
 
10774 
  def write(self, oprot):
10775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10777 
      return
10778 
    oprot.writeStructBegin('addInvoiceNumber_result')
10779 
    if self.ex is not None:
10780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10781 
      self.ex.write(oprot)
10782 
      oprot.writeFieldEnd()
10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
10786 
  def validate(self):
10787 
    return
10788 
 
10789 
 
10790 
  def __repr__(self):
10791 
    L = ['%s=%r' % (key, value)
10792 
      for key, value in self.__dict__.iteritems()]
10793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10794 
 
10795 
  def __eq__(self, other):
10796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10797 
 
10798 
  def __ne__(self, other):
10799 
    return not (self == other)
10800 
 
3064 chandransh 10801 
class markOrdersAsManifested_args:
1408 ankur.sing 10802 
  """
10803 
  Attributes:
3064 chandransh 10804 
   - warehouseId
1408 ankur.sing 10805 
   - providerId
3064 chandransh 10806 
   - cod
1408 ankur.sing 10807 
  """
10808 
 
10809 
  thrift_spec = (
10810 
    None, # 0
3064 chandransh 10811 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10812 
    (2, TType.I64, 'providerId', None, None, ), # 2
10813 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10814 
  )
10815 
 
3064 chandransh 10816 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10817 
    self.warehouseId = warehouseId
1408 ankur.sing 10818 
    self.providerId = providerId
3064 chandransh 10819 
    self.cod = cod
1408 ankur.sing 10820 
 
10821 
  def read(self, iprot):
10822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10824 
      return
10825 
    iprot.readStructBegin()
10826 
    while True:
10827 
      (fname, ftype, fid) = iprot.readFieldBegin()
10828 
      if ftype == TType.STOP:
10829 
        break
10830 
      if fid == 1:
10831 
        if ftype == TType.I64:
3064 chandransh 10832 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      elif fid == 2:
10836 
        if ftype == TType.I64:
3064 chandransh 10837 
          self.providerId = iprot.readI64();
1408 ankur.sing 10838 
        else:
10839 
          iprot.skip(ftype)
3064 chandransh 10840 
      elif fid == 3:
10841 
        if ftype == TType.BOOL:
10842 
          self.cod = iprot.readBool();
10843 
        else:
10844 
          iprot.skip(ftype)
1408 ankur.sing 10845 
      else:
10846 
        iprot.skip(ftype)
10847 
      iprot.readFieldEnd()
10848 
    iprot.readStructEnd()
10849 
 
10850 
  def write(self, oprot):
10851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10853 
      return
3064 chandransh 10854 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10855 
    if self.warehouseId is not None:
3064 chandransh 10856 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10857 
      oprot.writeI64(self.warehouseId)
10858 
      oprot.writeFieldEnd()
3431 rajveer 10859 
    if self.providerId is not None:
3064 chandransh 10860 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10861 
      oprot.writeI64(self.providerId)
10862 
      oprot.writeFieldEnd()
3431 rajveer 10863 
    if self.cod is not None:
3064 chandransh 10864 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10865 
      oprot.writeBool(self.cod)
1408 ankur.sing 10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
3431 rajveer 10870 
  def validate(self):
10871 
    return
10872 
 
10873 
 
1408 ankur.sing 10874 
  def __repr__(self):
10875 
    L = ['%s=%r' % (key, value)
10876 
      for key, value in self.__dict__.iteritems()]
10877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10878 
 
10879 
  def __eq__(self, other):
10880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10881 
 
10882 
  def __ne__(self, other):
10883 
    return not (self == other)
10884 
 
3064 chandransh 10885 
class markOrdersAsManifested_result:
1408 ankur.sing 10886 
  """
10887 
  Attributes:
10888 
   - success
3064 chandransh 10889 
   - ex
1408 ankur.sing 10890 
  """
10891 
 
10892 
  thrift_spec = (
3064 chandransh 10893 
    (0, TType.BOOL, 'success', None, None, ), # 0
10894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10895 
  )
10896 
 
3064 chandransh 10897 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10898 
    self.success = success
3064 chandransh 10899 
    self.ex = ex
1408 ankur.sing 10900 
 
10901 
  def read(self, iprot):
10902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10904 
      return
10905 
    iprot.readStructBegin()
10906 
    while True:
10907 
      (fname, ftype, fid) = iprot.readFieldBegin()
10908 
      if ftype == TType.STOP:
10909 
        break
10910 
      if fid == 0:
3064 chandransh 10911 
        if ftype == TType.BOOL:
10912 
          self.success = iprot.readBool();
1408 ankur.sing 10913 
        else:
10914 
          iprot.skip(ftype)
3064 chandransh 10915 
      elif fid == 1:
10916 
        if ftype == TType.STRUCT:
10917 
          self.ex = TransactionServiceException()
10918 
          self.ex.read(iprot)
10919 
        else:
10920 
          iprot.skip(ftype)
1408 ankur.sing 10921 
      else:
10922 
        iprot.skip(ftype)
10923 
      iprot.readFieldEnd()
10924 
    iprot.readStructEnd()
10925 
 
10926 
  def write(self, oprot):
10927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10929 
      return
3064 chandransh 10930 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10931 
    if self.success is not None:
3064 chandransh 10932 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10933 
      oprot.writeBool(self.success)
1408 ankur.sing 10934 
      oprot.writeFieldEnd()
3431 rajveer 10935 
    if self.ex is not None:
3064 chandransh 10936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10937 
      self.ex.write(oprot)
10938 
      oprot.writeFieldEnd()
1408 ankur.sing 10939 
    oprot.writeFieldStop()
10940 
    oprot.writeStructEnd()
10941 
 
3431 rajveer 10942 
  def validate(self):
10943 
    return
10944 
 
10945 
 
1408 ankur.sing 10946 
  def __repr__(self):
10947 
    L = ['%s=%r' % (key, value)
10948 
      for key, value in self.__dict__.iteritems()]
10949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10950 
 
10951 
  def __eq__(self, other):
10952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10953 
 
10954 
  def __ne__(self, other):
10955 
    return not (self == other)
10956 
 
4410 rajveer 10957 
class markOrdersAsShippedFromWarehouse_args:
10958 
  """
10959 
  Attributes:
10960 
   - warehouseId
10961 
   - providerId
10962 
   - cod
10963 
  """
10964 
 
10965 
  thrift_spec = (
10966 
    None, # 0
10967 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10968 
    (2, TType.I64, 'providerId', None, None, ), # 2
10969 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10970 
  )
10971 
 
10972 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10973 
    self.warehouseId = warehouseId
10974 
    self.providerId = providerId
10975 
    self.cod = cod
10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      if fid == 1:
10987 
        if ftype == TType.I64:
10988 
          self.warehouseId = iprot.readI64();
10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 2:
10992 
        if ftype == TType.I64:
10993 
          self.providerId = iprot.readI64();
10994 
        else:
10995 
          iprot.skip(ftype)
10996 
      elif fid == 3:
10997 
        if ftype == TType.BOOL:
10998 
          self.cod = iprot.readBool();
10999 
        else:
11000 
          iprot.skip(ftype)
11001 
      else:
11002 
        iprot.skip(ftype)
11003 
      iprot.readFieldEnd()
11004 
    iprot.readStructEnd()
11005 
 
11006 
  def write(self, oprot):
11007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11009 
      return
11010 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11011 
    if self.warehouseId is not None:
11012 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11013 
      oprot.writeI64(self.warehouseId)
11014 
      oprot.writeFieldEnd()
11015 
    if self.providerId is not None:
11016 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11017 
      oprot.writeI64(self.providerId)
11018 
      oprot.writeFieldEnd()
11019 
    if self.cod is not None:
11020 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11021 
      oprot.writeBool(self.cod)
11022 
      oprot.writeFieldEnd()
11023 
    oprot.writeFieldStop()
11024 
    oprot.writeStructEnd()
11025 
 
11026 
  def validate(self):
11027 
    return
11028 
 
11029 
 
11030 
  def __repr__(self):
11031 
    L = ['%s=%r' % (key, value)
11032 
      for key, value in self.__dict__.iteritems()]
11033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11034 
 
11035 
  def __eq__(self, other):
11036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11037 
 
11038 
  def __ne__(self, other):
11039 
    return not (self == other)
11040 
 
11041 
class markOrdersAsShippedFromWarehouse_result:
11042 
  """
11043 
  Attributes:
11044 
   - success
11045 
   - ex
11046 
  """
11047 
 
11048 
  thrift_spec = (
11049 
    (0, TType.BOOL, 'success', None, None, ), # 0
11050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11051 
  )
11052 
 
11053 
  def __init__(self, success=None, ex=None,):
11054 
    self.success = success
11055 
    self.ex = ex
11056 
 
11057 
  def read(self, iprot):
11058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11060 
      return
11061 
    iprot.readStructBegin()
11062 
    while True:
11063 
      (fname, ftype, fid) = iprot.readFieldBegin()
11064 
      if ftype == TType.STOP:
11065 
        break
11066 
      if fid == 0:
11067 
        if ftype == TType.BOOL:
11068 
          self.success = iprot.readBool();
11069 
        else:
11070 
          iprot.skip(ftype)
11071 
      elif fid == 1:
11072 
        if ftype == TType.STRUCT:
11073 
          self.ex = TransactionServiceException()
11074 
          self.ex.read(iprot)
11075 
        else:
11076 
          iprot.skip(ftype)
11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
11086 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11087 
    if self.success is not None:
11088 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11089 
      oprot.writeBool(self.success)
11090 
      oprot.writeFieldEnd()
11091 
    if self.ex is not None:
11092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11093 
      self.ex.write(oprot)
11094 
      oprot.writeFieldEnd()
11095 
    oprot.writeFieldStop()
11096 
    oprot.writeStructEnd()
11097 
 
11098 
  def validate(self):
11099 
    return
11100 
 
11101 
 
11102 
  def __repr__(self):
11103 
    L = ['%s=%r' % (key, value)
11104 
      for key, value in self.__dict__.iteritems()]
11105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11106 
 
11107 
  def __eq__(self, other):
11108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11109 
 
11110 
  def __ne__(self, other):
11111 
    return not (self == other)
11112 
 
3064 chandransh 11113 
class markOrdersAsPickedUp_args:
304 ashish 11114 
  """
11115 
  Attributes:
3064 chandransh 11116 
   - providerId
11117 
   - pickupDetails
304 ashish 11118 
  """
94 ashish 11119 
 
304 ashish 11120 
  thrift_spec = (
11121 
    None, # 0
3064 chandransh 11122 
    (1, TType.I64, 'providerId', None, None, ), # 1
11123 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11124 
  )
11125 
 
3064 chandransh 11126 
  def __init__(self, providerId=None, pickupDetails=None,):
11127 
    self.providerId = providerId
11128 
    self.pickupDetails = pickupDetails
304 ashish 11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      if fid == 1:
11140 
        if ftype == TType.I64:
3064 chandransh 11141 
          self.providerId = iprot.readI64();
304 ashish 11142 
        else:
11143 
          iprot.skip(ftype)
11144 
      elif fid == 2:
3064 chandransh 11145 
        if ftype == TType.MAP:
11146 
          self.pickupDetails = {}
4133 chandransh 11147 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
11148 
          for _i144 in xrange(_size140):
11149 
            _key145 = iprot.readString();
11150 
            _val146 = iprot.readString();
11151 
            self.pickupDetails[_key145] = _val146
3064 chandransh 11152 
          iprot.readMapEnd()
304 ashish 11153 
        else:
11154 
          iprot.skip(ftype)
11155 
      else:
11156 
        iprot.skip(ftype)
11157 
      iprot.readFieldEnd()
11158 
    iprot.readStructEnd()
11159 
 
11160 
  def write(self, oprot):
11161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11163 
      return
3064 chandransh 11164 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11165 
    if self.providerId is not None:
3064 chandransh 11166 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11167 
      oprot.writeI64(self.providerId)
304 ashish 11168 
      oprot.writeFieldEnd()
3431 rajveer 11169 
    if self.pickupDetails is not None:
3064 chandransh 11170 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11171 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11172 
      for kiter147,viter148 in self.pickupDetails.items():
11173 
        oprot.writeString(kiter147)
11174 
        oprot.writeString(viter148)
3064 chandransh 11175 
      oprot.writeMapEnd()
304 ashish 11176 
      oprot.writeFieldEnd()
11177 
    oprot.writeFieldStop()
11178 
    oprot.writeStructEnd()
11179 
 
3431 rajveer 11180 
  def validate(self):
11181 
    return
11182 
 
11183 
 
304 ashish 11184 
  def __repr__(self):
11185 
    L = ['%s=%r' % (key, value)
11186 
      for key, value in self.__dict__.iteritems()]
11187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11188 
 
11189 
  def __eq__(self, other):
11190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11191 
 
11192 
  def __ne__(self, other):
11193 
    return not (self == other)
11194 
 
3064 chandransh 11195 
class markOrdersAsPickedUp_result:
304 ashish 11196 
  """
11197 
  Attributes:
11198 
   - success
3064 chandransh 11199 
   - ex
304 ashish 11200 
  """
11201 
 
11202 
  thrift_spec = (
3064 chandransh 11203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11205 
  )
11206 
 
3064 chandransh 11207 
  def __init__(self, success=None, ex=None,):
304 ashish 11208 
    self.success = success
3064 chandransh 11209 
    self.ex = ex
304 ashish 11210 
 
11211 
  def read(self, iprot):
11212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11214 
      return
11215 
    iprot.readStructBegin()
11216 
    while True:
11217 
      (fname, ftype, fid) = iprot.readFieldBegin()
11218 
      if ftype == TType.STOP:
11219 
        break
11220 
      if fid == 0:
11221 
        if ftype == TType.LIST:
11222 
          self.success = []
4133 chandransh 11223 
          (_etype152, _size149) = iprot.readListBegin()
11224 
          for _i153 in xrange(_size149):
11225 
            _elem154 = Order()
11226 
            _elem154.read(iprot)
11227 
            self.success.append(_elem154)
304 ashish 11228 
          iprot.readListEnd()
11229 
        else:
11230 
          iprot.skip(ftype)
3064 chandransh 11231 
      elif fid == 1:
11232 
        if ftype == TType.STRUCT:
11233 
          self.ex = TransactionServiceException()
11234 
          self.ex.read(iprot)
11235 
        else:
11236 
          iprot.skip(ftype)
304 ashish 11237 
      else:
11238 
        iprot.skip(ftype)
11239 
      iprot.readFieldEnd()
11240 
    iprot.readStructEnd()
11241 
 
11242 
  def write(self, oprot):
11243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11245 
      return
3064 chandransh 11246 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11247 
    if self.success is not None:
304 ashish 11248 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11249 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11250 
      for iter155 in self.success:
11251 
        iter155.write(oprot)
304 ashish 11252 
      oprot.writeListEnd()
11253 
      oprot.writeFieldEnd()
3431 rajveer 11254 
    if self.ex is not None:
3064 chandransh 11255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11256 
      self.ex.write(oprot)
11257 
      oprot.writeFieldEnd()
304 ashish 11258 
    oprot.writeFieldStop()
11259 
    oprot.writeStructEnd()
11260 
 
3431 rajveer 11261 
  def validate(self):
11262 
    return
11263 
 
11264 
 
304 ashish 11265 
  def __repr__(self):
11266 
    L = ['%s=%r' % (key, value)
11267 
      for key, value in self.__dict__.iteritems()]
11268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11269 
 
11270 
  def __eq__(self, other):
11271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11272 
 
11273 
  def __ne__(self, other):
11274 
    return not (self == other)
11275 
 
3064 chandransh 11276 
class markOrdersAsDelivered_args:
304 ashish 11277 
  """
11278 
  Attributes:
3064 chandransh 11279 
   - providerId
11280 
   - deliveredOrders
304 ashish 11281 
  """
11282 
 
11283 
  thrift_spec = (
11284 
    None, # 0
3064 chandransh 11285 
    (1, TType.I64, 'providerId', None, None, ), # 1
11286 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11287 
  )
11288 
 
3064 chandransh 11289 
  def __init__(self, providerId=None, deliveredOrders=None,):
11290 
    self.providerId = providerId
11291 
    self.deliveredOrders = deliveredOrders
304 ashish 11292 
 
11293 
  def read(self, iprot):
11294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11296 
      return
11297 
    iprot.readStructBegin()
11298 
    while True:
11299 
      (fname, ftype, fid) = iprot.readFieldBegin()
11300 
      if ftype == TType.STOP:
11301 
        break
11302 
      if fid == 1:
11303 
        if ftype == TType.I64:
3064 chandransh 11304 
          self.providerId = iprot.readI64();
304 ashish 11305 
        else:
11306 
          iprot.skip(ftype)
11307 
      elif fid == 2:
3064 chandransh 11308 
        if ftype == TType.MAP:
11309 
          self.deliveredOrders = {}
4133 chandransh 11310 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11311 
          for _i160 in xrange(_size156):
11312 
            _key161 = iprot.readString();
11313 
            _val162 = iprot.readString();
11314 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11315 
          iprot.readMapEnd()
304 ashish 11316 
        else:
11317 
          iprot.skip(ftype)
11318 
      else:
11319 
        iprot.skip(ftype)
11320 
      iprot.readFieldEnd()
11321 
    iprot.readStructEnd()
11322 
 
11323 
  def write(self, oprot):
11324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11326 
      return
3064 chandransh 11327 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11328 
    if self.providerId is not None:
3064 chandransh 11329 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11330 
      oprot.writeI64(self.providerId)
304 ashish 11331 
      oprot.writeFieldEnd()
3431 rajveer 11332 
    if self.deliveredOrders is not None:
3064 chandransh 11333 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11334 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11335 
      for kiter163,viter164 in self.deliveredOrders.items():
11336 
        oprot.writeString(kiter163)
11337 
        oprot.writeString(viter164)
3064 chandransh 11338 
      oprot.writeMapEnd()
304 ashish 11339 
      oprot.writeFieldEnd()
11340 
    oprot.writeFieldStop()
11341 
    oprot.writeStructEnd()
11342 
 
3431 rajveer 11343 
  def validate(self):
11344 
    return
11345 
 
11346 
 
304 ashish 11347 
  def __repr__(self):
11348 
    L = ['%s=%r' % (key, value)
11349 
      for key, value in self.__dict__.iteritems()]
11350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11351 
 
11352 
  def __eq__(self, other):
11353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11354 
 
11355 
  def __ne__(self, other):
11356 
    return not (self == other)
11357 
 
3064 chandransh 11358 
class markOrdersAsDelivered_result:
11359 
  """
11360 
  Attributes:
11361 
   - ex
11362 
  """
304 ashish 11363 
 
11364 
  thrift_spec = (
3064 chandransh 11365 
    None, # 0
11366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11367 
  )
11368 
 
3064 chandransh 11369 
  def __init__(self, ex=None,):
11370 
    self.ex = ex
304 ashish 11371 
 
1596 ankur.sing 11372 
  def read(self, iprot):
11373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11375 
      return
11376 
    iprot.readStructBegin()
11377 
    while True:
11378 
      (fname, ftype, fid) = iprot.readFieldBegin()
11379 
      if ftype == TType.STOP:
11380 
        break
3064 chandransh 11381 
      if fid == 1:
11382 
        if ftype == TType.STRUCT:
11383 
          self.ex = TransactionServiceException()
11384 
          self.ex.read(iprot)
11385 
        else:
11386 
          iprot.skip(ftype)
1596 ankur.sing 11387 
      else:
11388 
        iprot.skip(ftype)
11389 
      iprot.readFieldEnd()
11390 
    iprot.readStructEnd()
11391 
 
11392 
  def write(self, oprot):
11393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11395 
      return
3064 chandransh 11396 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11397 
    if self.ex is not None:
3064 chandransh 11398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11399 
      self.ex.write(oprot)
11400 
      oprot.writeFieldEnd()
1596 ankur.sing 11401 
    oprot.writeFieldStop()
11402 
    oprot.writeStructEnd()
11403 
 
3431 rajveer 11404 
  def validate(self):
11405 
    return
11406 
 
11407 
 
1596 ankur.sing 11408 
  def __repr__(self):
11409 
    L = ['%s=%r' % (key, value)
11410 
      for key, value in self.__dict__.iteritems()]
11411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11412 
 
11413 
  def __eq__(self, other):
11414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11415 
 
11416 
  def __ne__(self, other):
11417 
    return not (self == other)
11418 
 
3064 chandransh 11419 
class markOrdersAsFailed_args:
1596 ankur.sing 11420 
  """
11421 
  Attributes:
3064 chandransh 11422 
   - providerId
11423 
   - returnedOrders
1596 ankur.sing 11424 
  """
11425 
 
11426 
  thrift_spec = (
3064 chandransh 11427 
    None, # 0
11428 
    (1, TType.I64, 'providerId', None, None, ), # 1
11429 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11430 
  )
11431 
 
3064 chandransh 11432 
  def __init__(self, providerId=None, returnedOrders=None,):
11433 
    self.providerId = providerId
11434 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11435 
 
11436 
  def read(self, iprot):
11437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11439 
      return
11440 
    iprot.readStructBegin()
11441 
    while True:
11442 
      (fname, ftype, fid) = iprot.readFieldBegin()
11443 
      if ftype == TType.STOP:
11444 
        break
3064 chandransh 11445 
      if fid == 1:
1596 ankur.sing 11446 
        if ftype == TType.I64:
3064 chandransh 11447 
          self.providerId = iprot.readI64();
1596 ankur.sing 11448 
        else:
11449 
          iprot.skip(ftype)
3064 chandransh 11450 
      elif fid == 2:
11451 
        if ftype == TType.MAP:
11452 
          self.returnedOrders = {}
4133 chandransh 11453 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11454 
          for _i169 in xrange(_size165):
11455 
            _key170 = iprot.readString();
11456 
            _val171 = iprot.readString();
11457 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11458 
          iprot.readMapEnd()
11459 
        else:
11460 
          iprot.skip(ftype)
1596 ankur.sing 11461 
      else:
11462 
        iprot.skip(ftype)
11463 
      iprot.readFieldEnd()
11464 
    iprot.readStructEnd()
11465 
 
11466 
  def write(self, oprot):
11467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11469 
      return
3064 chandransh 11470 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11471 
    if self.providerId is not None:
3064 chandransh 11472 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11473 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11474 
      oprot.writeFieldEnd()
3431 rajveer 11475 
    if self.returnedOrders is not None:
3064 chandransh 11476 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11477 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11478 
      for kiter172,viter173 in self.returnedOrders.items():
11479 
        oprot.writeString(kiter172)
11480 
        oprot.writeString(viter173)
3064 chandransh 11481 
      oprot.writeMapEnd()
11482 
      oprot.writeFieldEnd()
1596 ankur.sing 11483 
    oprot.writeFieldStop()
11484 
    oprot.writeStructEnd()
11485 
 
3431 rajveer 11486 
  def validate(self):
11487 
    return
11488 
 
11489 
 
1596 ankur.sing 11490 
  def __repr__(self):
11491 
    L = ['%s=%r' % (key, value)
11492 
      for key, value in self.__dict__.iteritems()]
11493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11494 
 
11495 
  def __eq__(self, other):
11496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11497 
 
11498 
  def __ne__(self, other):
11499 
    return not (self == other)
11500 
 
3064 chandransh 11501 
class markOrdersAsFailed_result:
11502 
  """
11503 
  Attributes:
11504 
   - ex
11505 
  """
1596 ankur.sing 11506 
 
1627 ankur.sing 11507 
  thrift_spec = (
3064 chandransh 11508 
    None, # 0
11509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11510 
  )
11511 
 
3064 chandransh 11512 
  def __init__(self, ex=None,):
11513 
    self.ex = ex
11514 
 
1627 ankur.sing 11515 
  def read(self, iprot):
11516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11518 
      return
11519 
    iprot.readStructBegin()
11520 
    while True:
11521 
      (fname, ftype, fid) = iprot.readFieldBegin()
11522 
      if ftype == TType.STOP:
11523 
        break
3064 chandransh 11524 
      if fid == 1:
11525 
        if ftype == TType.STRUCT:
11526 
          self.ex = TransactionServiceException()
11527 
          self.ex.read(iprot)
11528 
        else:
11529 
          iprot.skip(ftype)
1627 ankur.sing 11530 
      else:
11531 
        iprot.skip(ftype)
11532 
      iprot.readFieldEnd()
11533 
    iprot.readStructEnd()
11534 
 
11535 
  def write(self, oprot):
11536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11538 
      return
3064 chandransh 11539 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11540 
    if self.ex is not None:
3064 chandransh 11541 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11542 
      self.ex.write(oprot)
11543 
      oprot.writeFieldEnd()
1627 ankur.sing 11544 
    oprot.writeFieldStop()
11545 
    oprot.writeStructEnd()
11546 
 
3431 rajveer 11547 
  def validate(self):
11548 
    return
11549 
 
11550 
 
1627 ankur.sing 11551 
  def __repr__(self):
11552 
    L = ['%s=%r' % (key, value)
11553 
      for key, value in self.__dict__.iteritems()]
11554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11555 
 
11556 
  def __eq__(self, other):
11557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11558 
 
11559 
  def __ne__(self, other):
11560 
    return not (self == other)
11561 
 
3064 chandransh 11562 
class updateNonDeliveryReason_args:
1627 ankur.sing 11563 
  """
11564 
  Attributes:
3064 chandransh 11565 
   - providerId
11566 
   - undeliveredOrders
1627 ankur.sing 11567 
  """
11568 
 
11569 
  thrift_spec = (
3064 chandransh 11570 
    None, # 0
11571 
    (1, TType.I64, 'providerId', None, None, ), # 1
11572 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11573 
  )
11574 
 
3064 chandransh 11575 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11576 
    self.providerId = providerId
11577 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11578 
 
11579 
  def read(self, iprot):
11580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11582 
      return
11583 
    iprot.readStructBegin()
11584 
    while True:
11585 
      (fname, ftype, fid) = iprot.readFieldBegin()
11586 
      if ftype == TType.STOP:
11587 
        break
3064 chandransh 11588 
      if fid == 1:
1627 ankur.sing 11589 
        if ftype == TType.I64:
3064 chandransh 11590 
          self.providerId = iprot.readI64();
1627 ankur.sing 11591 
        else:
11592 
          iprot.skip(ftype)
3064 chandransh 11593 
      elif fid == 2:
11594 
        if ftype == TType.MAP:
11595 
          self.undeliveredOrders = {}
4133 chandransh 11596 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11597 
          for _i178 in xrange(_size174):
11598 
            _key179 = iprot.readString();
11599 
            _val180 = iprot.readString();
11600 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11601 
          iprot.readMapEnd()
11602 
        else:
11603 
          iprot.skip(ftype)
1627 ankur.sing 11604 
      else:
11605 
        iprot.skip(ftype)
11606 
      iprot.readFieldEnd()
11607 
    iprot.readStructEnd()
11608 
 
11609 
  def write(self, oprot):
11610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11612 
      return
3064 chandransh 11613 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11614 
    if self.providerId is not None:
3064 chandransh 11615 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11616 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11617 
      oprot.writeFieldEnd()
3431 rajveer 11618 
    if self.undeliveredOrders is not None:
3064 chandransh 11619 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11620 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11621 
      for kiter181,viter182 in self.undeliveredOrders.items():
11622 
        oprot.writeString(kiter181)
11623 
        oprot.writeString(viter182)
3064 chandransh 11624 
      oprot.writeMapEnd()
11625 
      oprot.writeFieldEnd()
1627 ankur.sing 11626 
    oprot.writeFieldStop()
11627 
    oprot.writeStructEnd()
11628 
 
3431 rajveer 11629 
  def validate(self):
11630 
    return
11631 
 
11632 
 
1627 ankur.sing 11633 
  def __repr__(self):
11634 
    L = ['%s=%r' % (key, value)
11635 
      for key, value in self.__dict__.iteritems()]
11636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11637 
 
11638 
  def __eq__(self, other):
11639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11640 
 
11641 
  def __ne__(self, other):
11642 
    return not (self == other)
11643 
 
3064 chandransh 11644 
class updateNonDeliveryReason_result:
1627 ankur.sing 11645 
  """
11646 
  Attributes:
4581 phani.kuma 11647 
   - success
3064 chandransh 11648 
   - ex
1627 ankur.sing 11649 
  """
11650 
 
11651 
  thrift_spec = (
4581 phani.kuma 11652 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11654 
  )
11655 
 
4581 phani.kuma 11656 
  def __init__(self, success=None, ex=None,):
11657 
    self.success = success
3064 chandransh 11658 
    self.ex = ex
1627 ankur.sing 11659 
 
11660 
  def read(self, iprot):
11661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11663 
      return
11664 
    iprot.readStructBegin()
11665 
    while True:
11666 
      (fname, ftype, fid) = iprot.readFieldBegin()
11667 
      if ftype == TType.STOP:
11668 
        break
4581 phani.kuma 11669 
      if fid == 0:
11670 
        if ftype == TType.LIST:
11671 
          self.success = []
11672 
          (_etype186, _size183) = iprot.readListBegin()
11673 
          for _i187 in xrange(_size183):
11674 
            _elem188 = Order()
11675 
            _elem188.read(iprot)
11676 
            self.success.append(_elem188)
11677 
          iprot.readListEnd()
11678 
        else:
11679 
          iprot.skip(ftype)
11680 
      elif fid == 1:
3064 chandransh 11681 
        if ftype == TType.STRUCT:
11682 
          self.ex = TransactionServiceException()
11683 
          self.ex.read(iprot)
1627 ankur.sing 11684 
        else:
11685 
          iprot.skip(ftype)
11686 
      else:
11687 
        iprot.skip(ftype)
11688 
      iprot.readFieldEnd()
11689 
    iprot.readStructEnd()
11690 
 
11691 
  def write(self, oprot):
11692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11694 
      return
3064 chandransh 11695 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11696 
    if self.success is not None:
11697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11699 
      for iter189 in self.success:
11700 
        iter189.write(oprot)
11701 
      oprot.writeListEnd()
11702 
      oprot.writeFieldEnd()
3431 rajveer 11703 
    if self.ex is not None:
3064 chandransh 11704 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11705 
      self.ex.write(oprot)
1627 ankur.sing 11706 
      oprot.writeFieldEnd()
11707 
    oprot.writeFieldStop()
11708 
    oprot.writeStructEnd()
11709 
 
3431 rajveer 11710 
  def validate(self):
11711 
    return
11712 
 
11713 
 
1627 ankur.sing 11714 
  def __repr__(self):
11715 
    L = ['%s=%r' % (key, value)
11716 
      for key, value in self.__dict__.iteritems()]
11717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11718 
 
11719 
  def __eq__(self, other):
11720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11721 
 
11722 
  def __ne__(self, other):
11723 
    return not (self == other)
11724 
 
3064 chandransh 11725 
class getUndeliveredOrders_args:
1886 ankur.sing 11726 
  """
11727 
  Attributes:
3064 chandransh 11728 
   - providerId
11729 
   - warehouseId
1886 ankur.sing 11730 
  """
1627 ankur.sing 11731 
 
1886 ankur.sing 11732 
  thrift_spec = (
11733 
    None, # 0
3064 chandransh 11734 
    (1, TType.I64, 'providerId', None, None, ), # 1
11735 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11736 
  )
11737 
 
3064 chandransh 11738 
  def __init__(self, providerId=None, warehouseId=None,):
11739 
    self.providerId = providerId
11740 
    self.warehouseId = warehouseId
1886 ankur.sing 11741 
 
11742 
  def read(self, iprot):
11743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11745 
      return
11746 
    iprot.readStructBegin()
11747 
    while True:
11748 
      (fname, ftype, fid) = iprot.readFieldBegin()
11749 
      if ftype == TType.STOP:
11750 
        break
11751 
      if fid == 1:
11752 
        if ftype == TType.I64:
3064 chandransh 11753 
          self.providerId = iprot.readI64();
1886 ankur.sing 11754 
        else:
11755 
          iprot.skip(ftype)
3064 chandransh 11756 
      elif fid == 2:
11757 
        if ftype == TType.I64:
11758 
          self.warehouseId = iprot.readI64();
11759 
        else:
11760 
          iprot.skip(ftype)
1886 ankur.sing 11761 
      else:
11762 
        iprot.skip(ftype)
11763 
      iprot.readFieldEnd()
11764 
    iprot.readStructEnd()
11765 
 
11766 
  def write(self, oprot):
11767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11769 
      return
3064 chandransh 11770 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11771 
    if self.providerId is not None:
3064 chandransh 11772 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11773 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11774 
      oprot.writeFieldEnd()
3431 rajveer 11775 
    if self.warehouseId is not None:
3064 chandransh 11776 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11777 
      oprot.writeI64(self.warehouseId)
11778 
      oprot.writeFieldEnd()
1886 ankur.sing 11779 
    oprot.writeFieldStop()
11780 
    oprot.writeStructEnd()
11781 
 
3431 rajveer 11782 
  def validate(self):
11783 
    return
11784 
 
11785 
 
1886 ankur.sing 11786 
  def __repr__(self):
11787 
    L = ['%s=%r' % (key, value)
11788 
      for key, value in self.__dict__.iteritems()]
11789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11790 
 
11791 
  def __eq__(self, other):
11792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11793 
 
11794 
  def __ne__(self, other):
11795 
    return not (self == other)
11796 
 
3064 chandransh 11797 
class getUndeliveredOrders_result:
1886 ankur.sing 11798 
  """
11799 
  Attributes:
11800 
   - success
11801 
  """
11802 
 
11803 
  thrift_spec = (
11804 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11805 
  )
11806 
 
11807 
  def __init__(self, success=None,):
11808 
    self.success = success
11809 
 
11810 
  def read(self, iprot):
11811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11813 
      return
11814 
    iprot.readStructBegin()
11815 
    while True:
11816 
      (fname, ftype, fid) = iprot.readFieldBegin()
11817 
      if ftype == TType.STOP:
11818 
        break
11819 
      if fid == 0:
11820 
        if ftype == TType.LIST:
11821 
          self.success = []
4581 phani.kuma 11822 
          (_etype193, _size190) = iprot.readListBegin()
11823 
          for _i194 in xrange(_size190):
11824 
            _elem195 = Order()
11825 
            _elem195.read(iprot)
11826 
            self.success.append(_elem195)
1886 ankur.sing 11827 
          iprot.readListEnd()
11828 
        else:
11829 
          iprot.skip(ftype)
11830 
      else:
11831 
        iprot.skip(ftype)
11832 
      iprot.readFieldEnd()
11833 
    iprot.readStructEnd()
11834 
 
11835 
  def write(self, oprot):
11836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11838 
      return
3064 chandransh 11839 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11840 
    if self.success is not None:
1886 ankur.sing 11841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11843 
      for iter196 in self.success:
11844 
        iter196.write(oprot)
1886 ankur.sing 11845 
      oprot.writeListEnd()
11846 
      oprot.writeFieldEnd()
11847 
    oprot.writeFieldStop()
11848 
    oprot.writeStructEnd()
11849 
 
3431 rajveer 11850 
  def validate(self):
11851 
    return
11852 
 
11853 
 
1886 ankur.sing 11854 
  def __repr__(self):
11855 
    L = ['%s=%r' % (key, value)
11856 
      for key, value in self.__dict__.iteritems()]
11857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11858 
 
11859 
  def __eq__(self, other):
11860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11861 
 
11862 
  def __ne__(self, other):
11863 
    return not (self == other)
11864 
 
2536 chandransh 11865 
class toggleDOAFlag_args:
11866 
  """
11867 
  Attributes:
11868 
   - orderId
11869 
  """
1886 ankur.sing 11870 
 
2536 chandransh 11871 
  thrift_spec = (
11872 
    None, # 0
11873 
    (1, TType.I64, 'orderId', None, None, ), # 1
11874 
  )
11875 
 
11876 
  def __init__(self, orderId=None,):
11877 
    self.orderId = orderId
11878 
 
11879 
  def read(self, iprot):
11880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11882 
      return
11883 
    iprot.readStructBegin()
11884 
    while True:
11885 
      (fname, ftype, fid) = iprot.readFieldBegin()
11886 
      if ftype == TType.STOP:
11887 
        break
11888 
      if fid == 1:
11889 
        if ftype == TType.I64:
11890 
          self.orderId = iprot.readI64();
11891 
        else:
11892 
          iprot.skip(ftype)
11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
11902 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11903 
    if self.orderId is not None:
2536 chandransh 11904 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11905 
      oprot.writeI64(self.orderId)
11906 
      oprot.writeFieldEnd()
11907 
    oprot.writeFieldStop()
11908 
    oprot.writeStructEnd()
11909 
 
3431 rajveer 11910 
  def validate(self):
11911 
    return
11912 
 
11913 
 
2536 chandransh 11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
11925 
class toggleDOAFlag_result:
11926 
  """
11927 
  Attributes:
11928 
   - success
11929 
   - ex
11930 
  """
11931 
 
11932 
  thrift_spec = (
11933 
    (0, TType.BOOL, 'success', None, None, ), # 0
11934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11935 
  )
11936 
 
11937 
  def __init__(self, success=None, ex=None,):
11938 
    self.success = success
11939 
    self.ex = ex
11940 
 
11941 
  def read(self, iprot):
11942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11944 
      return
11945 
    iprot.readStructBegin()
11946 
    while True:
11947 
      (fname, ftype, fid) = iprot.readFieldBegin()
11948 
      if ftype == TType.STOP:
11949 
        break
11950 
      if fid == 0:
11951 
        if ftype == TType.BOOL:
11952 
          self.success = iprot.readBool();
11953 
        else:
11954 
          iprot.skip(ftype)
11955 
      elif fid == 1:
11956 
        if ftype == TType.STRUCT:
11957 
          self.ex = TransactionServiceException()
11958 
          self.ex.read(iprot)
11959 
        else:
11960 
          iprot.skip(ftype)
11961 
      else:
11962 
        iprot.skip(ftype)
11963 
      iprot.readFieldEnd()
11964 
    iprot.readStructEnd()
11965 
 
11966 
  def write(self, oprot):
11967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11969 
      return
11970 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11971 
    if self.success is not None:
2536 chandransh 11972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11973 
      oprot.writeBool(self.success)
11974 
      oprot.writeFieldEnd()
3431 rajveer 11975 
    if self.ex is not None:
2536 chandransh 11976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11977 
      self.ex.write(oprot)
11978 
      oprot.writeFieldEnd()
11979 
    oprot.writeFieldStop()
11980 
    oprot.writeStructEnd()
11981 
 
3431 rajveer 11982 
  def validate(self):
11983 
    return
11984 
 
11985 
 
2536 chandransh 11986 
  def __repr__(self):
11987 
    L = ['%s=%r' % (key, value)
11988 
      for key, value in self.__dict__.iteritems()]
11989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11990 
 
11991 
  def __eq__(self, other):
11992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11993 
 
11994 
  def __ne__(self, other):
11995 
    return not (self == other)
11996 
 
4712 rajveer 11997 
class markOrderAsDelivered_args:
11998 
  """
11999 
  Attributes:
12000 
   - orderId
12001 
   - deliveryTimestamp
12002 
   - receiver
12003 
  """
12004 
 
12005 
  thrift_spec = None
12006 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12007 
    self.orderId = orderId
12008 
    self.deliveryTimestamp = deliveryTimestamp
12009 
    self.receiver = receiver
12010 
 
12011 
  def read(self, iprot):
12012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12014 
      return
12015 
    iprot.readStructBegin()
12016 
    while True:
12017 
      (fname, ftype, fid) = iprot.readFieldBegin()
12018 
      if ftype == TType.STOP:
12019 
        break
12020 
      if fid == 1:
12021 
        if ftype == TType.I64:
12022 
          self.orderId = iprot.readI64();
12023 
        else:
12024 
          iprot.skip(ftype)
12025 
      elif fid == 2:
12026 
        if ftype == TType.I64:
12027 
          self.deliveryTimestamp = iprot.readI64();
12028 
        else:
12029 
          iprot.skip(ftype)
12030 
      elif fid == -1:
12031 
        if ftype == TType.STRING:
12032 
          self.receiver = iprot.readString();
12033 
        else:
12034 
          iprot.skip(ftype)
12035 
      else:
12036 
        iprot.skip(ftype)
12037 
      iprot.readFieldEnd()
12038 
    iprot.readStructEnd()
12039 
 
12040 
  def write(self, oprot):
12041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12043 
      return
12044 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12045 
    if self.receiver is not None:
12046 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12047 
      oprot.writeString(self.receiver)
12048 
      oprot.writeFieldEnd()
12049 
    if self.orderId is not None:
12050 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12051 
      oprot.writeI64(self.orderId)
12052 
      oprot.writeFieldEnd()
12053 
    if self.deliveryTimestamp is not None:
12054 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12055 
      oprot.writeI64(self.deliveryTimestamp)
12056 
      oprot.writeFieldEnd()
12057 
    oprot.writeFieldStop()
12058 
    oprot.writeStructEnd()
12059 
 
12060 
  def validate(self):
12061 
    return
12062 
 
12063 
 
12064 
  def __repr__(self):
12065 
    L = ['%s=%r' % (key, value)
12066 
      for key, value in self.__dict__.iteritems()]
12067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12068 
 
12069 
  def __eq__(self, other):
12070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12071 
 
12072 
  def __ne__(self, other):
12073 
    return not (self == other)
12074 
 
12075 
class markOrderAsDelivered_result:
12076 
  """
12077 
  Attributes:
12078 
   - ex
12079 
  """
12080 
 
12081 
  thrift_spec = (
12082 
    None, # 0
12083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12084 
  )
12085 
 
12086 
  def __init__(self, ex=None,):
12087 
    self.ex = ex
12088 
 
12089 
  def read(self, iprot):
12090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12092 
      return
12093 
    iprot.readStructBegin()
12094 
    while True:
12095 
      (fname, ftype, fid) = iprot.readFieldBegin()
12096 
      if ftype == TType.STOP:
12097 
        break
12098 
      if fid == 1:
12099 
        if ftype == TType.STRUCT:
12100 
          self.ex = TransactionServiceException()
12101 
          self.ex.read(iprot)
12102 
        else:
12103 
          iprot.skip(ftype)
12104 
      else:
12105 
        iprot.skip(ftype)
12106 
      iprot.readFieldEnd()
12107 
    iprot.readStructEnd()
12108 
 
12109 
  def write(self, oprot):
12110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12112 
      return
12113 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12114 
    if self.ex is not None:
12115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12116 
      self.ex.write(oprot)
12117 
      oprot.writeFieldEnd()
12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
12121 
  def validate(self):
12122 
    return
12123 
 
12124 
 
12125 
  def __repr__(self):
12126 
    L = ['%s=%r' % (key, value)
12127 
      for key, value in self.__dict__.iteritems()]
12128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12129 
 
12130 
  def __eq__(self, other):
12131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12132 
 
12133 
  def __ne__(self, other):
12134 
    return not (self == other)
12135 
 
4454 rajveer 12136 
class markOrderDoaRequestReceived_args:
12137 
  """
12138 
  Attributes:
12139 
   - orderId
12140 
  """
12141 
 
12142 
  thrift_spec = (
12143 
    None, # 0
12144 
    (1, TType.I64, 'orderId', None, None, ), # 1
12145 
  )
12146 
 
12147 
  def __init__(self, orderId=None,):
12148 
    self.orderId = orderId
12149 
 
12150 
  def read(self, iprot):
12151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12153 
      return
12154 
    iprot.readStructBegin()
12155 
    while True:
12156 
      (fname, ftype, fid) = iprot.readFieldBegin()
12157 
      if ftype == TType.STOP:
12158 
        break
12159 
      if fid == 1:
12160 
        if ftype == TType.I64:
12161 
          self.orderId = iprot.readI64();
12162 
        else:
12163 
          iprot.skip(ftype)
12164 
      else:
12165 
        iprot.skip(ftype)
12166 
      iprot.readFieldEnd()
12167 
    iprot.readStructEnd()
12168 
 
12169 
  def write(self, oprot):
12170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12172 
      return
12173 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12174 
    if self.orderId is not None:
12175 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12176 
      oprot.writeI64(self.orderId)
12177 
      oprot.writeFieldEnd()
12178 
    oprot.writeFieldStop()
12179 
    oprot.writeStructEnd()
12180 
 
12181 
  def validate(self):
12182 
    return
12183 
 
12184 
 
12185 
  def __repr__(self):
12186 
    L = ['%s=%r' % (key, value)
12187 
      for key, value in self.__dict__.iteritems()]
12188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12189 
 
12190 
  def __eq__(self, other):
12191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12192 
 
12193 
  def __ne__(self, other):
12194 
    return not (self == other)
12195 
 
12196 
class markOrderDoaRequestReceived_result:
12197 
  """
12198 
  Attributes:
12199 
   - success
12200 
   - ex
12201 
  """
12202 
 
12203 
  thrift_spec = (
12204 
    (0, TType.BOOL, 'success', None, None, ), # 0
12205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12206 
  )
12207 
 
12208 
  def __init__(self, success=None, ex=None,):
12209 
    self.success = success
12210 
    self.ex = ex
12211 
 
12212 
  def read(self, iprot):
12213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12215 
      return
12216 
    iprot.readStructBegin()
12217 
    while True:
12218 
      (fname, ftype, fid) = iprot.readFieldBegin()
12219 
      if ftype == TType.STOP:
12220 
        break
12221 
      if fid == 0:
12222 
        if ftype == TType.BOOL:
12223 
          self.success = iprot.readBool();
12224 
        else:
12225 
          iprot.skip(ftype)
12226 
      elif fid == 1:
12227 
        if ftype == TType.STRUCT:
12228 
          self.ex = TransactionServiceException()
12229 
          self.ex.read(iprot)
12230 
        else:
12231 
          iprot.skip(ftype)
12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
12241 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12242 
    if self.success is not None:
12243 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12244 
      oprot.writeBool(self.success)
12245 
      oprot.writeFieldEnd()
12246 
    if self.ex is not None:
12247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12248 
      self.ex.write(oprot)
12249 
      oprot.writeFieldEnd()
12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
12253 
  def validate(self):
12254 
    return
12255 
 
12256 
 
12257 
  def __repr__(self):
12258 
    L = ['%s=%r' % (key, value)
12259 
      for key, value in self.__dict__.iteritems()]
12260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12261 
 
12262 
  def __eq__(self, other):
12263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12264 
 
12265 
  def __ne__(self, other):
12266 
    return not (self == other)
12267 
 
12268 
class markOrderDoaRequestAuthorized_args:
12269 
  """
12270 
  Attributes:
12271 
   - orderId
12272 
   - isAuthorized
12273 
  """
12274 
 
12275 
  thrift_spec = (
12276 
    None, # 0
12277 
    (1, TType.I64, 'orderId', None, None, ), # 1
12278 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12279 
  )
12280 
 
12281 
  def __init__(self, orderId=None, isAuthorized=None,):
12282 
    self.orderId = orderId
12283 
    self.isAuthorized = isAuthorized
12284 
 
12285 
  def read(self, iprot):
12286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12288 
      return
12289 
    iprot.readStructBegin()
12290 
    while True:
12291 
      (fname, ftype, fid) = iprot.readFieldBegin()
12292 
      if ftype == TType.STOP:
12293 
        break
12294 
      if fid == 1:
12295 
        if ftype == TType.I64:
12296 
          self.orderId = iprot.readI64();
12297 
        else:
12298 
          iprot.skip(ftype)
12299 
      elif fid == 2:
12300 
        if ftype == TType.BOOL:
12301 
          self.isAuthorized = iprot.readBool();
12302 
        else:
12303 
          iprot.skip(ftype)
12304 
      else:
12305 
        iprot.skip(ftype)
12306 
      iprot.readFieldEnd()
12307 
    iprot.readStructEnd()
12308 
 
12309 
  def write(self, oprot):
12310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12312 
      return
12313 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12314 
    if self.orderId is not None:
12315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12316 
      oprot.writeI64(self.orderId)
12317 
      oprot.writeFieldEnd()
12318 
    if self.isAuthorized is not None:
12319 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12320 
      oprot.writeBool(self.isAuthorized)
12321 
      oprot.writeFieldEnd()
12322 
    oprot.writeFieldStop()
12323 
    oprot.writeStructEnd()
12324 
 
12325 
  def validate(self):
12326 
    return
12327 
 
12328 
 
12329 
  def __repr__(self):
12330 
    L = ['%s=%r' % (key, value)
12331 
      for key, value in self.__dict__.iteritems()]
12332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12333 
 
12334 
  def __eq__(self, other):
12335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12336 
 
12337 
  def __ne__(self, other):
12338 
    return not (self == other)
12339 
 
12340 
class markOrderDoaRequestAuthorized_result:
12341 
  """
12342 
  Attributes:
12343 
   - success
12344 
   - ex
12345 
  """
12346 
 
12347 
  thrift_spec = (
12348 
    (0, TType.BOOL, 'success', None, None, ), # 0
12349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12350 
  )
12351 
 
12352 
  def __init__(self, success=None, ex=None,):
12353 
    self.success = success
12354 
    self.ex = ex
12355 
 
12356 
  def read(self, iprot):
12357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12359 
      return
12360 
    iprot.readStructBegin()
12361 
    while True:
12362 
      (fname, ftype, fid) = iprot.readFieldBegin()
12363 
      if ftype == TType.STOP:
12364 
        break
12365 
      if fid == 0:
12366 
        if ftype == TType.BOOL:
12367 
          self.success = iprot.readBool();
12368 
        else:
12369 
          iprot.skip(ftype)
12370 
      elif fid == 1:
12371 
        if ftype == TType.STRUCT:
12372 
          self.ex = TransactionServiceException()
12373 
          self.ex.read(iprot)
12374 
        else:
12375 
          iprot.skip(ftype)
12376 
      else:
12377 
        iprot.skip(ftype)
12378 
      iprot.readFieldEnd()
12379 
    iprot.readStructEnd()
12380 
 
12381 
  def write(self, oprot):
12382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12384 
      return
12385 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12386 
    if self.success is not None:
12387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12388 
      oprot.writeBool(self.success)
12389 
      oprot.writeFieldEnd()
12390 
    if self.ex is not None:
12391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12392 
      self.ex.write(oprot)
12393 
      oprot.writeFieldEnd()
12394 
    oprot.writeFieldStop()
12395 
    oprot.writeStructEnd()
12396 
 
12397 
  def validate(self):
12398 
    return
12399 
 
12400 
 
12401 
  def __repr__(self):
12402 
    L = ['%s=%r' % (key, value)
12403 
      for key, value in self.__dict__.iteritems()]
12404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12405 
 
12406 
  def __eq__(self, other):
12407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12408 
 
12409 
  def __ne__(self, other):
12410 
    return not (self == other)
12411 
 
4488 rajveer 12412 
class markOrderReturnRequestReceived_args:
12413 
  """
12414 
  Attributes:
12415 
   - orderId
12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    None, # 0
12420 
    (1, TType.I64, 'orderId', None, None, ), # 1
12421 
  )
12422 
 
12423 
  def __init__(self, orderId=None,):
12424 
    self.orderId = orderId
12425 
 
12426 
  def read(self, iprot):
12427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12429 
      return
12430 
    iprot.readStructBegin()
12431 
    while True:
12432 
      (fname, ftype, fid) = iprot.readFieldBegin()
12433 
      if ftype == TType.STOP:
12434 
        break
12435 
      if fid == 1:
12436 
        if ftype == TType.I64:
12437 
          self.orderId = iprot.readI64();
12438 
        else:
12439 
          iprot.skip(ftype)
12440 
      else:
12441 
        iprot.skip(ftype)
12442 
      iprot.readFieldEnd()
12443 
    iprot.readStructEnd()
12444 
 
12445 
  def write(self, oprot):
12446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12448 
      return
12449 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12450 
    if self.orderId is not None:
12451 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12452 
      oprot.writeI64(self.orderId)
12453 
      oprot.writeFieldEnd()
12454 
    oprot.writeFieldStop()
12455 
    oprot.writeStructEnd()
12456 
 
12457 
  def validate(self):
12458 
    return
12459 
 
12460 
 
12461 
  def __repr__(self):
12462 
    L = ['%s=%r' % (key, value)
12463 
      for key, value in self.__dict__.iteritems()]
12464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12465 
 
12466 
  def __eq__(self, other):
12467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12468 
 
12469 
  def __ne__(self, other):
12470 
    return not (self == other)
12471 
 
12472 
class markOrderReturnRequestReceived_result:
12473 
  """
12474 
  Attributes:
12475 
   - success
12476 
   - ex
12477 
  """
12478 
 
12479 
  thrift_spec = (
12480 
    (0, TType.BOOL, 'success', None, None, ), # 0
12481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12482 
  )
12483 
 
12484 
  def __init__(self, success=None, ex=None,):
12485 
    self.success = success
12486 
    self.ex = ex
12487 
 
12488 
  def read(self, iprot):
12489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12491 
      return
12492 
    iprot.readStructBegin()
12493 
    while True:
12494 
      (fname, ftype, fid) = iprot.readFieldBegin()
12495 
      if ftype == TType.STOP:
12496 
        break
12497 
      if fid == 0:
12498 
        if ftype == TType.BOOL:
12499 
          self.success = iprot.readBool();
12500 
        else:
12501 
          iprot.skip(ftype)
12502 
      elif fid == 1:
12503 
        if ftype == TType.STRUCT:
12504 
          self.ex = TransactionServiceException()
12505 
          self.ex.read(iprot)
12506 
        else:
12507 
          iprot.skip(ftype)
12508 
      else:
12509 
        iprot.skip(ftype)
12510 
      iprot.readFieldEnd()
12511 
    iprot.readStructEnd()
12512 
 
12513 
  def write(self, oprot):
12514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12516 
      return
12517 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12518 
    if self.success is not None:
12519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12520 
      oprot.writeBool(self.success)
12521 
      oprot.writeFieldEnd()
12522 
    if self.ex is not None:
12523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12524 
      self.ex.write(oprot)
12525 
      oprot.writeFieldEnd()
12526 
    oprot.writeFieldStop()
12527 
    oprot.writeStructEnd()
12528 
 
12529 
  def validate(self):
12530 
    return
12531 
 
12532 
 
12533 
  def __repr__(self):
12534 
    L = ['%s=%r' % (key, value)
12535 
      for key, value in self.__dict__.iteritems()]
12536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12537 
 
12538 
  def __eq__(self, other):
12539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12540 
 
12541 
  def __ne__(self, other):
12542 
    return not (self == other)
12543 
 
12544 
class markOrderReturnRequestAuthorized_args:
12545 
  """
12546 
  Attributes:
12547 
   - orderId
12548 
   - isAuthorized
12549 
  """
12550 
 
12551 
  thrift_spec = (
12552 
    None, # 0
12553 
    (1, TType.I64, 'orderId', None, None, ), # 1
12554 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12555 
  )
12556 
 
12557 
  def __init__(self, orderId=None, isAuthorized=None,):
12558 
    self.orderId = orderId
12559 
    self.isAuthorized = isAuthorized
12560 
 
12561 
  def read(self, iprot):
12562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12564 
      return
12565 
    iprot.readStructBegin()
12566 
    while True:
12567 
      (fname, ftype, fid) = iprot.readFieldBegin()
12568 
      if ftype == TType.STOP:
12569 
        break
12570 
      if fid == 1:
12571 
        if ftype == TType.I64:
12572 
          self.orderId = iprot.readI64();
12573 
        else:
12574 
          iprot.skip(ftype)
12575 
      elif fid == 2:
12576 
        if ftype == TType.BOOL:
12577 
          self.isAuthorized = iprot.readBool();
12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      else:
12581 
        iprot.skip(ftype)
12582 
      iprot.readFieldEnd()
12583 
    iprot.readStructEnd()
12584 
 
12585 
  def write(self, oprot):
12586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12588 
      return
12589 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12590 
    if self.orderId is not None:
12591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12592 
      oprot.writeI64(self.orderId)
12593 
      oprot.writeFieldEnd()
12594 
    if self.isAuthorized is not None:
12595 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12596 
      oprot.writeBool(self.isAuthorized)
12597 
      oprot.writeFieldEnd()
12598 
    oprot.writeFieldStop()
12599 
    oprot.writeStructEnd()
12600 
 
12601 
  def validate(self):
12602 
    return
12603 
 
12604 
 
12605 
  def __repr__(self):
12606 
    L = ['%s=%r' % (key, value)
12607 
      for key, value in self.__dict__.iteritems()]
12608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12609 
 
12610 
  def __eq__(self, other):
12611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12612 
 
12613 
  def __ne__(self, other):
12614 
    return not (self == other)
12615 
 
12616 
class markOrderReturnRequestAuthorized_result:
12617 
  """
12618 
  Attributes:
12619 
   - success
12620 
   - ex
12621 
  """
12622 
 
12623 
  thrift_spec = (
12624 
    (0, TType.BOOL, 'success', None, None, ), # 0
12625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12626 
  )
12627 
 
12628 
  def __init__(self, success=None, ex=None,):
12629 
    self.success = success
12630 
    self.ex = ex
12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 0:
12642 
        if ftype == TType.BOOL:
12643 
          self.success = iprot.readBool();
12644 
        else:
12645 
          iprot.skip(ftype)
12646 
      elif fid == 1:
12647 
        if ftype == TType.STRUCT:
12648 
          self.ex = TransactionServiceException()
12649 
          self.ex.read(iprot)
12650 
        else:
12651 
          iprot.skip(ftype)
12652 
      else:
12653 
        iprot.skip(ftype)
12654 
      iprot.readFieldEnd()
12655 
    iprot.readStructEnd()
12656 
 
12657 
  def write(self, oprot):
12658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12660 
      return
12661 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12662 
    if self.success is not None:
12663 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12664 
      oprot.writeBool(self.success)
12665 
      oprot.writeFieldEnd()
12666 
    if self.ex is not None:
12667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12668 
      self.ex.write(oprot)
12669 
      oprot.writeFieldEnd()
12670 
    oprot.writeFieldStop()
12671 
    oprot.writeStructEnd()
12672 
 
12673 
  def validate(self):
12674 
    return
12675 
 
12676 
 
12677 
  def __repr__(self):
12678 
    L = ['%s=%r' % (key, value)
12679 
      for key, value in self.__dict__.iteritems()]
12680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12681 
 
12682 
  def __eq__(self, other):
12683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12684 
 
12685 
  def __ne__(self, other):
12686 
    return not (self == other)
12687 
 
2536 chandransh 12688 
class requestPickupNumber_args:
12689 
  """
12690 
  Attributes:
12691 
   - orderId
4579 rajveer 12692 
   - providerId
2536 chandransh 12693 
  """
12694 
 
12695 
  thrift_spec = (
12696 
    None, # 0
12697 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12698 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12699 
  )
12700 
 
4579 rajveer 12701 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12702 
    self.orderId = orderId
4579 rajveer 12703 
    self.providerId = providerId
2536 chandransh 12704 
 
12705 
  def read(self, iprot):
12706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12708 
      return
12709 
    iprot.readStructBegin()
12710 
    while True:
12711 
      (fname, ftype, fid) = iprot.readFieldBegin()
12712 
      if ftype == TType.STOP:
12713 
        break
12714 
      if fid == 1:
12715 
        if ftype == TType.I64:
12716 
          self.orderId = iprot.readI64();
12717 
        else:
12718 
          iprot.skip(ftype)
4579 rajveer 12719 
      elif fid == 2:
12720 
        if ftype == TType.I64:
12721 
          self.providerId = iprot.readI64();
12722 
        else:
12723 
          iprot.skip(ftype)
2536 chandransh 12724 
      else:
12725 
        iprot.skip(ftype)
12726 
      iprot.readFieldEnd()
12727 
    iprot.readStructEnd()
12728 
 
12729 
  def write(self, oprot):
12730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12732 
      return
12733 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12734 
    if self.orderId is not None:
2536 chandransh 12735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12736 
      oprot.writeI64(self.orderId)
12737 
      oprot.writeFieldEnd()
4579 rajveer 12738 
    if self.providerId is not None:
12739 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12740 
      oprot.writeI64(self.providerId)
12741 
      oprot.writeFieldEnd()
2536 chandransh 12742 
    oprot.writeFieldStop()
12743 
    oprot.writeStructEnd()
12744 
 
3431 rajveer 12745 
  def validate(self):
12746 
    return
12747 
 
12748 
 
2536 chandransh 12749 
  def __repr__(self):
12750 
    L = ['%s=%r' % (key, value)
12751 
      for key, value in self.__dict__.iteritems()]
12752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12753 
 
12754 
  def __eq__(self, other):
12755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12756 
 
12757 
  def __ne__(self, other):
12758 
    return not (self == other)
12759 
 
12760 
class requestPickupNumber_result:
12761 
  """
12762 
  Attributes:
12763 
   - success
12764 
   - ex
12765 
  """
12766 
 
12767 
  thrift_spec = (
12768 
    (0, TType.BOOL, 'success', None, None, ), # 0
12769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12770 
  )
12771 
 
12772 
  def __init__(self, success=None, ex=None,):
12773 
    self.success = success
12774 
    self.ex = ex
12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 0:
12786 
        if ftype == TType.BOOL:
12787 
          self.success = iprot.readBool();
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 1:
12791 
        if ftype == TType.STRUCT:
12792 
          self.ex = TransactionServiceException()
12793 
          self.ex.read(iprot)
12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      else:
12797 
        iprot.skip(ftype)
12798 
      iprot.readFieldEnd()
12799 
    iprot.readStructEnd()
12800 
 
12801 
  def write(self, oprot):
12802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12804 
      return
12805 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12806 
    if self.success is not None:
2536 chandransh 12807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12808 
      oprot.writeBool(self.success)
12809 
      oprot.writeFieldEnd()
3431 rajveer 12810 
    if self.ex is not None:
2536 chandransh 12811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12812 
      self.ex.write(oprot)
12813 
      oprot.writeFieldEnd()
12814 
    oprot.writeFieldStop()
12815 
    oprot.writeStructEnd()
12816 
 
3431 rajveer 12817 
  def validate(self):
12818 
    return
12819 
 
12820 
 
2536 chandransh 12821 
  def __repr__(self):
12822 
    L = ['%s=%r' % (key, value)
12823 
      for key, value in self.__dict__.iteritems()]
12824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12825 
 
12826 
  def __eq__(self, other):
12827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12828 
 
12829 
  def __ne__(self, other):
12830 
    return not (self == other)
12831 
 
12832 
class authorizePickup_args:
12833 
  """
12834 
  Attributes:
12835 
   - orderId
12836 
   - pickupNumber
4602 rajveer 12837 
   - providerId
2536 chandransh 12838 
  """
12839 
 
12840 
  thrift_spec = (
12841 
    None, # 0
12842 
    (1, TType.I64, 'orderId', None, None, ), # 1
12843 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12844 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12845 
  )
12846 
 
4602 rajveer 12847 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12848 
    self.orderId = orderId
12849 
    self.pickupNumber = pickupNumber
4602 rajveer 12850 
    self.providerId = providerId
2536 chandransh 12851 
 
12852 
  def read(self, iprot):
12853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12855 
      return
12856 
    iprot.readStructBegin()
12857 
    while True:
12858 
      (fname, ftype, fid) = iprot.readFieldBegin()
12859 
      if ftype == TType.STOP:
12860 
        break
12861 
      if fid == 1:
12862 
        if ftype == TType.I64:
12863 
          self.orderId = iprot.readI64();
12864 
        else:
12865 
          iprot.skip(ftype)
12866 
      elif fid == 2:
12867 
        if ftype == TType.STRING:
12868 
          self.pickupNumber = iprot.readString();
12869 
        else:
12870 
          iprot.skip(ftype)
4602 rajveer 12871 
      elif fid == 3:
12872 
        if ftype == TType.I64:
12873 
          self.providerId = iprot.readI64();
12874 
        else:
12875 
          iprot.skip(ftype)
2536 chandransh 12876 
      else:
12877 
        iprot.skip(ftype)
12878 
      iprot.readFieldEnd()
12879 
    iprot.readStructEnd()
12880 
 
12881 
  def write(self, oprot):
12882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12884 
      return
12885 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12886 
    if self.orderId is not None:
2536 chandransh 12887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12888 
      oprot.writeI64(self.orderId)
12889 
      oprot.writeFieldEnd()
3431 rajveer 12890 
    if self.pickupNumber is not None:
2536 chandransh 12891 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12892 
      oprot.writeString(self.pickupNumber)
12893 
      oprot.writeFieldEnd()
4602 rajveer 12894 
    if self.providerId is not None:
12895 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12896 
      oprot.writeI64(self.providerId)
12897 
      oprot.writeFieldEnd()
2536 chandransh 12898 
    oprot.writeFieldStop()
12899 
    oprot.writeStructEnd()
12900 
 
3431 rajveer 12901 
  def validate(self):
12902 
    return
12903 
 
12904 
 
2536 chandransh 12905 
  def __repr__(self):
12906 
    L = ['%s=%r' % (key, value)
12907 
      for key, value in self.__dict__.iteritems()]
12908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12909 
 
12910 
  def __eq__(self, other):
12911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12912 
 
12913 
  def __ne__(self, other):
12914 
    return not (self == other)
12915 
 
12916 
class authorizePickup_result:
12917 
  """
12918 
  Attributes:
12919 
   - success
12920 
   - ex
12921 
  """
12922 
 
12923 
  thrift_spec = (
12924 
    (0, TType.BOOL, 'success', None, None, ), # 0
12925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12926 
  )
12927 
 
12928 
  def __init__(self, success=None, ex=None,):
12929 
    self.success = success
12930 
    self.ex = ex
12931 
 
12932 
  def read(self, iprot):
12933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12935 
      return
12936 
    iprot.readStructBegin()
12937 
    while True:
12938 
      (fname, ftype, fid) = iprot.readFieldBegin()
12939 
      if ftype == TType.STOP:
12940 
        break
12941 
      if fid == 0:
12942 
        if ftype == TType.BOOL:
12943 
          self.success = iprot.readBool();
12944 
        else:
12945 
          iprot.skip(ftype)
12946 
      elif fid == 1:
12947 
        if ftype == TType.STRUCT:
12948 
          self.ex = TransactionServiceException()
12949 
          self.ex.read(iprot)
12950 
        else:
12951 
          iprot.skip(ftype)
12952 
      else:
12953 
        iprot.skip(ftype)
12954 
      iprot.readFieldEnd()
12955 
    iprot.readStructEnd()
12956 
 
12957 
  def write(self, oprot):
12958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12960 
      return
12961 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12962 
    if self.success is not None:
2536 chandransh 12963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12964 
      oprot.writeBool(self.success)
12965 
      oprot.writeFieldEnd()
3431 rajveer 12966 
    if self.ex is not None:
2536 chandransh 12967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12968 
      self.ex.write(oprot)
12969 
      oprot.writeFieldEnd()
12970 
    oprot.writeFieldStop()
12971 
    oprot.writeStructEnd()
12972 
 
3431 rajveer 12973 
  def validate(self):
12974 
    return
12975 
 
12976 
 
2536 chandransh 12977 
  def __repr__(self):
12978 
    L = ['%s=%r' % (key, value)
12979 
      for key, value in self.__dict__.iteritems()]
12980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12981 
 
12982 
  def __eq__(self, other):
12983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12984 
 
12985 
  def __ne__(self, other):
12986 
    return not (self == other)
12987 
 
2764 chandransh 12988 
class markDoasAsPickedUp_args:
12989 
  """
12990 
  Attributes:
12991 
   - providerId
12992 
   - pickupDetails
12993 
  """
12994 
 
12995 
  thrift_spec = (
12996 
    None, # 0
12997 
    (1, TType.I64, 'providerId', None, None, ), # 1
12998 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12999 
  )
13000 
 
13001 
  def __init__(self, providerId=None, pickupDetails=None,):
13002 
    self.providerId = providerId
13003 
    self.pickupDetails = pickupDetails
13004 
 
13005 
  def read(self, iprot):
13006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13008 
      return
13009 
    iprot.readStructBegin()
13010 
    while True:
13011 
      (fname, ftype, fid) = iprot.readFieldBegin()
13012 
      if ftype == TType.STOP:
13013 
        break
13014 
      if fid == 1:
13015 
        if ftype == TType.I64:
13016 
          self.providerId = iprot.readI64();
13017 
        else:
13018 
          iprot.skip(ftype)
13019 
      elif fid == 2:
13020 
        if ftype == TType.MAP:
13021 
          self.pickupDetails = {}
4581 phani.kuma 13022 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
13023 
          for _i201 in xrange(_size197):
13024 
            _key202 = iprot.readString();
13025 
            _val203 = iprot.readString();
13026 
            self.pickupDetails[_key202] = _val203
2764 chandransh 13027 
          iprot.readMapEnd()
13028 
        else:
13029 
          iprot.skip(ftype)
13030 
      else:
13031 
        iprot.skip(ftype)
13032 
      iprot.readFieldEnd()
13033 
    iprot.readStructEnd()
13034 
 
13035 
  def write(self, oprot):
13036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13038 
      return
13039 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13040 
    if self.providerId is not None:
2764 chandransh 13041 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13042 
      oprot.writeI64(self.providerId)
13043 
      oprot.writeFieldEnd()
3431 rajveer 13044 
    if self.pickupDetails is not None:
2764 chandransh 13045 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13046 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 13047 
      for kiter204,viter205 in self.pickupDetails.items():
13048 
        oprot.writeString(kiter204)
13049 
        oprot.writeString(viter205)
2764 chandransh 13050 
      oprot.writeMapEnd()
13051 
      oprot.writeFieldEnd()
13052 
    oprot.writeFieldStop()
13053 
    oprot.writeStructEnd()
13054 
 
3431 rajveer 13055 
  def validate(self):
13056 
    return
13057 
 
13058 
 
2764 chandransh 13059 
  def __repr__(self):
13060 
    L = ['%s=%r' % (key, value)
13061 
      for key, value in self.__dict__.iteritems()]
13062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13063 
 
13064 
  def __eq__(self, other):
13065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13066 
 
13067 
  def __ne__(self, other):
13068 
    return not (self == other)
13069 
 
13070 
class markDoasAsPickedUp_result:
13071 
  """
13072 
  Attributes:
13073 
   - success
13074 
  """
13075 
 
13076 
  thrift_spec = (
13077 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13078 
  )
13079 
 
13080 
  def __init__(self, success=None,):
13081 
    self.success = success
13082 
 
13083 
  def read(self, iprot):
13084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13086 
      return
13087 
    iprot.readStructBegin()
13088 
    while True:
13089 
      (fname, ftype, fid) = iprot.readFieldBegin()
13090 
      if ftype == TType.STOP:
13091 
        break
13092 
      if fid == 0:
13093 
        if ftype == TType.LIST:
13094 
          self.success = []
4581 phani.kuma 13095 
          (_etype209, _size206) = iprot.readListBegin()
13096 
          for _i210 in xrange(_size206):
13097 
            _elem211 = Order()
13098 
            _elem211.read(iprot)
13099 
            self.success.append(_elem211)
2764 chandransh 13100 
          iprot.readListEnd()
13101 
        else:
13102 
          iprot.skip(ftype)
13103 
      else:
13104 
        iprot.skip(ftype)
13105 
      iprot.readFieldEnd()
13106 
    iprot.readStructEnd()
13107 
 
13108 
  def write(self, oprot):
13109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13111 
      return
13112 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13113 
    if self.success is not None:
2764 chandransh 13114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13116 
      for iter212 in self.success:
13117 
        iter212.write(oprot)
2764 chandransh 13118 
      oprot.writeListEnd()
13119 
      oprot.writeFieldEnd()
13120 
    oprot.writeFieldStop()
13121 
    oprot.writeStructEnd()
13122 
 
3431 rajveer 13123 
  def validate(self):
13124 
    return
13125 
 
13126 
 
2764 chandransh 13127 
  def __repr__(self):
13128 
    L = ['%s=%r' % (key, value)
13129 
      for key, value in self.__dict__.iteritems()]
13130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13131 
 
13132 
  def __eq__(self, other):
13133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13134 
 
13135 
  def __ne__(self, other):
13136 
    return not (self == other)
13137 
 
4741 phani.kuma 13138 
class markReturnOrdersAsPickedUp_args:
13139 
  """
13140 
  Attributes:
13141 
   - providerId
13142 
   - pickupDetails
13143 
  """
13144 
 
13145 
  thrift_spec = (
13146 
    None, # 0
13147 
    (1, TType.I64, 'providerId', None, None, ), # 1
13148 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13149 
  )
13150 
 
13151 
  def __init__(self, providerId=None, pickupDetails=None,):
13152 
    self.providerId = providerId
13153 
    self.pickupDetails = pickupDetails
13154 
 
13155 
  def read(self, iprot):
13156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13158 
      return
13159 
    iprot.readStructBegin()
13160 
    while True:
13161 
      (fname, ftype, fid) = iprot.readFieldBegin()
13162 
      if ftype == TType.STOP:
13163 
        break
13164 
      if fid == 1:
13165 
        if ftype == TType.I64:
13166 
          self.providerId = iprot.readI64();
13167 
        else:
13168 
          iprot.skip(ftype)
13169 
      elif fid == 2:
13170 
        if ftype == TType.MAP:
13171 
          self.pickupDetails = {}
13172 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13173 
          for _i217 in xrange(_size213):
13174 
            _key218 = iprot.readString();
13175 
            _val219 = iprot.readString();
13176 
            self.pickupDetails[_key218] = _val219
13177 
          iprot.readMapEnd()
13178 
        else:
13179 
          iprot.skip(ftype)
13180 
      else:
13181 
        iprot.skip(ftype)
13182 
      iprot.readFieldEnd()
13183 
    iprot.readStructEnd()
13184 
 
13185 
  def write(self, oprot):
13186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13188 
      return
13189 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13190 
    if self.providerId is not None:
13191 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13192 
      oprot.writeI64(self.providerId)
13193 
      oprot.writeFieldEnd()
13194 
    if self.pickupDetails is not None:
13195 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13196 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
13197 
      for kiter220,viter221 in self.pickupDetails.items():
13198 
        oprot.writeString(kiter220)
13199 
        oprot.writeString(viter221)
13200 
      oprot.writeMapEnd()
13201 
      oprot.writeFieldEnd()
13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
13220 
class markReturnOrdersAsPickedUp_result:
13221 
  """
13222 
  Attributes:
13223 
   - success
13224 
  """
13225 
 
13226 
  thrift_spec = (
13227 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13228 
  )
13229 
 
13230 
  def __init__(self, success=None,):
13231 
    self.success = success
13232 
 
13233 
  def read(self, iprot):
13234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13236 
      return
13237 
    iprot.readStructBegin()
13238 
    while True:
13239 
      (fname, ftype, fid) = iprot.readFieldBegin()
13240 
      if ftype == TType.STOP:
13241 
        break
13242 
      if fid == 0:
13243 
        if ftype == TType.LIST:
13244 
          self.success = []
13245 
          (_etype225, _size222) = iprot.readListBegin()
13246 
          for _i226 in xrange(_size222):
13247 
            _elem227 = Order()
13248 
            _elem227.read(iprot)
13249 
            self.success.append(_elem227)
13250 
          iprot.readListEnd()
13251 
        else:
13252 
          iprot.skip(ftype)
13253 
      else:
13254 
        iprot.skip(ftype)
13255 
      iprot.readFieldEnd()
13256 
    iprot.readStructEnd()
13257 
 
13258 
  def write(self, oprot):
13259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13261 
      return
13262 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13263 
    if self.success is not None:
13264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13266 
      for iter228 in self.success:
13267 
        iter228.write(oprot)
13268 
      oprot.writeListEnd()
13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
2616 chandransh 13288 
class receiveReturn_args:
2591 chandransh 13289 
  """
13290 
  Attributes:
13291 
   - orderId
4479 rajveer 13292 
   - receiveCondition
2591 chandransh 13293 
  """
2536 chandransh 13294 
 
2591 chandransh 13295 
  thrift_spec = (
13296 
    None, # 0
13297 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13298 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13299 
  )
13300 
 
4479 rajveer 13301 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13302 
    self.orderId = orderId
4479 rajveer 13303 
    self.receiveCondition = receiveCondition
2591 chandransh 13304 
 
13305 
  def read(self, iprot):
13306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13308 
      return
13309 
    iprot.readStructBegin()
13310 
    while True:
13311 
      (fname, ftype, fid) = iprot.readFieldBegin()
13312 
      if ftype == TType.STOP:
13313 
        break
13314 
      if fid == 1:
13315 
        if ftype == TType.I64:
13316 
          self.orderId = iprot.readI64();
13317 
        else:
13318 
          iprot.skip(ftype)
4479 rajveer 13319 
      elif fid == 2:
13320 
        if ftype == TType.I64:
13321 
          self.receiveCondition = iprot.readI64();
13322 
        else:
13323 
          iprot.skip(ftype)
2591 chandransh 13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
2616 chandransh 13333 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13334 
    if self.orderId is not None:
2591 chandransh 13335 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13336 
      oprot.writeI64(self.orderId)
13337 
      oprot.writeFieldEnd()
4479 rajveer 13338 
    if self.receiveCondition is not None:
13339 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13340 
      oprot.writeI64(self.receiveCondition)
13341 
      oprot.writeFieldEnd()
2591 chandransh 13342 
    oprot.writeFieldStop()
13343 
    oprot.writeStructEnd()
13344 
 
3431 rajveer 13345 
  def validate(self):
13346 
    return
13347 
 
13348 
 
2591 chandransh 13349 
  def __repr__(self):
13350 
    L = ['%s=%r' % (key, value)
13351 
      for key, value in self.__dict__.iteritems()]
13352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13353 
 
13354 
  def __eq__(self, other):
13355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13356 
 
13357 
  def __ne__(self, other):
13358 
    return not (self == other)
13359 
 
2616 chandransh 13360 
class receiveReturn_result:
2591 chandransh 13361 
  """
13362 
  Attributes:
13363 
   - success
13364 
   - ex
13365 
  """
13366 
 
13367 
  thrift_spec = (
13368 
    (0, TType.BOOL, 'success', None, None, ), # 0
13369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13370 
  )
13371 
 
13372 
  def __init__(self, success=None, ex=None,):
13373 
    self.success = success
13374 
    self.ex = ex
13375 
 
13376 
  def read(self, iprot):
13377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13379 
      return
13380 
    iprot.readStructBegin()
13381 
    while True:
13382 
      (fname, ftype, fid) = iprot.readFieldBegin()
13383 
      if ftype == TType.STOP:
13384 
        break
13385 
      if fid == 0:
13386 
        if ftype == TType.BOOL:
13387 
          self.success = iprot.readBool();
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      elif fid == 1:
13391 
        if ftype == TType.STRUCT:
13392 
          self.ex = TransactionServiceException()
13393 
          self.ex.read(iprot)
13394 
        else:
13395 
          iprot.skip(ftype)
13396 
      else:
13397 
        iprot.skip(ftype)
13398 
      iprot.readFieldEnd()
13399 
    iprot.readStructEnd()
13400 
 
13401 
  def write(self, oprot):
13402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13404 
      return
2616 chandransh 13405 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13406 
    if self.success is not None:
2591 chandransh 13407 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13408 
      oprot.writeBool(self.success)
13409 
      oprot.writeFieldEnd()
3431 rajveer 13410 
    if self.ex is not None:
2591 chandransh 13411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13412 
      self.ex.write(oprot)
13413 
      oprot.writeFieldEnd()
13414 
    oprot.writeFieldStop()
13415 
    oprot.writeStructEnd()
13416 
 
3431 rajveer 13417 
  def validate(self):
13418 
    return
13419 
 
13420 
 
2591 chandransh 13421 
  def __repr__(self):
13422 
    L = ['%s=%r' % (key, value)
13423 
      for key, value in self.__dict__.iteritems()]
13424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13425 
 
13426 
  def __eq__(self, other):
13427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13428 
 
13429 
  def __ne__(self, other):
13430 
    return not (self == other)
13431 
 
13432 
class validateDoa_args:
13433 
  """
13434 
  Attributes:
13435 
   - orderId
13436 
   - isValid
13437 
  """
13438 
 
13439 
  thrift_spec = (
13440 
    None, # 0
13441 
    (1, TType.I64, 'orderId', None, None, ), # 1
13442 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13443 
  )
13444 
 
13445 
  def __init__(self, orderId=None, isValid=None,):
13446 
    self.orderId = orderId
13447 
    self.isValid = isValid
13448 
 
13449 
  def read(self, iprot):
13450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13452 
      return
13453 
    iprot.readStructBegin()
13454 
    while True:
13455 
      (fname, ftype, fid) = iprot.readFieldBegin()
13456 
      if ftype == TType.STOP:
13457 
        break
13458 
      if fid == 1:
13459 
        if ftype == TType.I64:
13460 
          self.orderId = iprot.readI64();
13461 
        else:
13462 
          iprot.skip(ftype)
13463 
      elif fid == 2:
13464 
        if ftype == TType.BOOL:
13465 
          self.isValid = iprot.readBool();
13466 
        else:
13467 
          iprot.skip(ftype)
13468 
      else:
13469 
        iprot.skip(ftype)
13470 
      iprot.readFieldEnd()
13471 
    iprot.readStructEnd()
13472 
 
13473 
  def write(self, oprot):
13474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13476 
      return
13477 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13478 
    if self.orderId is not None:
2591 chandransh 13479 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13480 
      oprot.writeI64(self.orderId)
13481 
      oprot.writeFieldEnd()
3431 rajveer 13482 
    if self.isValid is not None:
2591 chandransh 13483 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13484 
      oprot.writeBool(self.isValid)
13485 
      oprot.writeFieldEnd()
13486 
    oprot.writeFieldStop()
13487 
    oprot.writeStructEnd()
13488 
 
3431 rajveer 13489 
  def validate(self):
13490 
    return
13491 
 
13492 
 
2591 chandransh 13493 
  def __repr__(self):
13494 
    L = ['%s=%r' % (key, value)
13495 
      for key, value in self.__dict__.iteritems()]
13496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13497 
 
13498 
  def __eq__(self, other):
13499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13500 
 
13501 
  def __ne__(self, other):
13502 
    return not (self == other)
13503 
 
13504 
class validateDoa_result:
13505 
  """
13506 
  Attributes:
13507 
   - success
13508 
   - ex
13509 
  """
13510 
 
13511 
  thrift_spec = (
13512 
    (0, TType.BOOL, 'success', None, None, ), # 0
13513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13514 
  )
13515 
 
13516 
  def __init__(self, success=None, ex=None,):
13517 
    self.success = success
13518 
    self.ex = ex
13519 
 
13520 
  def read(self, iprot):
13521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13523 
      return
13524 
    iprot.readStructBegin()
13525 
    while True:
13526 
      (fname, ftype, fid) = iprot.readFieldBegin()
13527 
      if ftype == TType.STOP:
13528 
        break
13529 
      if fid == 0:
13530 
        if ftype == TType.BOOL:
13531 
          self.success = iprot.readBool();
13532 
        else:
13533 
          iprot.skip(ftype)
13534 
      elif fid == 1:
13535 
        if ftype == TType.STRUCT:
13536 
          self.ex = TransactionServiceException()
13537 
          self.ex.read(iprot)
13538 
        else:
13539 
          iprot.skip(ftype)
13540 
      else:
13541 
        iprot.skip(ftype)
13542 
      iprot.readFieldEnd()
13543 
    iprot.readStructEnd()
13544 
 
13545 
  def write(self, oprot):
13546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13548 
      return
13549 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13550 
    if self.success is not None:
2591 chandransh 13551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13552 
      oprot.writeBool(self.success)
13553 
      oprot.writeFieldEnd()
3431 rajveer 13554 
    if self.ex is not None:
2591 chandransh 13555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13556 
      self.ex.write(oprot)
13557 
      oprot.writeFieldEnd()
13558 
    oprot.writeFieldStop()
13559 
    oprot.writeStructEnd()
13560 
 
3431 rajveer 13561 
  def validate(self):
13562 
    return
13563 
 
13564 
 
2591 chandransh 13565 
  def __repr__(self):
13566 
    L = ['%s=%r' % (key, value)
13567 
      for key, value in self.__dict__.iteritems()]
13568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13569 
 
13570 
  def __eq__(self, other):
13571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13572 
 
13573 
  def __ne__(self, other):
13574 
    return not (self == other)
13575 
 
4495 rajveer 13576 
class validateReturnProduct_args:
13577 
  """
13578 
  Attributes:
13579 
   - orderId
13580 
   - isUsable
13581 
  """
13582 
 
13583 
  thrift_spec = (
13584 
    None, # 0
13585 
    (1, TType.I64, 'orderId', None, None, ), # 1
13586 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13587 
  )
13588 
 
13589 
  def __init__(self, orderId=None, isUsable=None,):
13590 
    self.orderId = orderId
13591 
    self.isUsable = isUsable
13592 
 
13593 
  def read(self, iprot):
13594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13596 
      return
13597 
    iprot.readStructBegin()
13598 
    while True:
13599 
      (fname, ftype, fid) = iprot.readFieldBegin()
13600 
      if ftype == TType.STOP:
13601 
        break
13602 
      if fid == 1:
13603 
        if ftype == TType.I64:
13604 
          self.orderId = iprot.readI64();
13605 
        else:
13606 
          iprot.skip(ftype)
13607 
      elif fid == 2:
13608 
        if ftype == TType.BOOL:
13609 
          self.isUsable = iprot.readBool();
13610 
        else:
13611 
          iprot.skip(ftype)
13612 
      else:
13613 
        iprot.skip(ftype)
13614 
      iprot.readFieldEnd()
13615 
    iprot.readStructEnd()
13616 
 
13617 
  def write(self, oprot):
13618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13620 
      return
13621 
    oprot.writeStructBegin('validateReturnProduct_args')
13622 
    if self.orderId is not None:
13623 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13624 
      oprot.writeI64(self.orderId)
13625 
      oprot.writeFieldEnd()
13626 
    if self.isUsable is not None:
13627 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13628 
      oprot.writeBool(self.isUsable)
13629 
      oprot.writeFieldEnd()
13630 
    oprot.writeFieldStop()
13631 
    oprot.writeStructEnd()
13632 
 
13633 
  def validate(self):
13634 
    return
13635 
 
13636 
 
13637 
  def __repr__(self):
13638 
    L = ['%s=%r' % (key, value)
13639 
      for key, value in self.__dict__.iteritems()]
13640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13641 
 
13642 
  def __eq__(self, other):
13643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13644 
 
13645 
  def __ne__(self, other):
13646 
    return not (self == other)
13647 
 
13648 
class validateReturnProduct_result:
13649 
  """
13650 
  Attributes:
13651 
   - success
13652 
   - ex
13653 
  """
13654 
 
13655 
  thrift_spec = (
13656 
    (0, TType.BOOL, 'success', None, None, ), # 0
13657 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13658 
  )
13659 
 
13660 
  def __init__(self, success=None, ex=None,):
13661 
    self.success = success
13662 
    self.ex = ex
13663 
 
13664 
  def read(self, iprot):
13665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13667 
      return
13668 
    iprot.readStructBegin()
13669 
    while True:
13670 
      (fname, ftype, fid) = iprot.readFieldBegin()
13671 
      if ftype == TType.STOP:
13672 
        break
13673 
      if fid == 0:
13674 
        if ftype == TType.BOOL:
13675 
          self.success = iprot.readBool();
13676 
        else:
13677 
          iprot.skip(ftype)
13678 
      elif fid == 1:
13679 
        if ftype == TType.STRUCT:
13680 
          self.ex = TransactionServiceException()
13681 
          self.ex.read(iprot)
13682 
        else:
13683 
          iprot.skip(ftype)
13684 
      else:
13685 
        iprot.skip(ftype)
13686 
      iprot.readFieldEnd()
13687 
    iprot.readStructEnd()
13688 
 
13689 
  def write(self, oprot):
13690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13692 
      return
13693 
    oprot.writeStructBegin('validateReturnProduct_result')
13694 
    if self.success is not None:
13695 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13696 
      oprot.writeBool(self.success)
13697 
      oprot.writeFieldEnd()
13698 
    if self.ex is not None:
13699 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13700 
      self.ex.write(oprot)
13701 
      oprot.writeFieldEnd()
13702 
    oprot.writeFieldStop()
13703 
    oprot.writeStructEnd()
13704 
 
13705 
  def validate(self):
13706 
    return
13707 
 
13708 
 
13709 
  def __repr__(self):
13710 
    L = ['%s=%r' % (key, value)
13711 
      for key, value in self.__dict__.iteritems()]
13712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13713 
 
13714 
  def __eq__(self, other):
13715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13716 
 
13717 
  def __ne__(self, other):
13718 
    return not (self == other)
13719 
 
2616 chandransh 13720 
class reshipOrder_args:
13721 
  """
13722 
  Attributes:
13723 
   - orderId
13724 
  """
2591 chandransh 13725 
 
2616 chandransh 13726 
  thrift_spec = (
13727 
    None, # 0
13728 
    (1, TType.I64, 'orderId', None, None, ), # 1
13729 
  )
13730 
 
13731 
  def __init__(self, orderId=None,):
13732 
    self.orderId = orderId
13733 
 
13734 
  def read(self, iprot):
13735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13737 
      return
13738 
    iprot.readStructBegin()
13739 
    while True:
13740 
      (fname, ftype, fid) = iprot.readFieldBegin()
13741 
      if ftype == TType.STOP:
13742 
        break
13743 
      if fid == 1:
13744 
        if ftype == TType.I64:
13745 
          self.orderId = iprot.readI64();
13746 
        else:
13747 
          iprot.skip(ftype)
13748 
      else:
13749 
        iprot.skip(ftype)
13750 
      iprot.readFieldEnd()
13751 
    iprot.readStructEnd()
13752 
 
13753 
  def write(self, oprot):
13754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13756 
      return
13757 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13758 
    if self.orderId is not None:
2616 chandransh 13759 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13760 
      oprot.writeI64(self.orderId)
13761 
      oprot.writeFieldEnd()
13762 
    oprot.writeFieldStop()
13763 
    oprot.writeStructEnd()
13764 
 
3431 rajveer 13765 
  def validate(self):
13766 
    return
13767 
 
13768 
 
2616 chandransh 13769 
  def __repr__(self):
13770 
    L = ['%s=%r' % (key, value)
13771 
      for key, value in self.__dict__.iteritems()]
13772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13773 
 
13774 
  def __eq__(self, other):
13775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13776 
 
13777 
  def __ne__(self, other):
13778 
    return not (self == other)
13779 
 
13780 
class reshipOrder_result:
13781 
  """
13782 
  Attributes:
13783 
   - success
13784 
   - ex
13785 
  """
13786 
 
13787 
  thrift_spec = (
13788 
    (0, TType.I64, 'success', None, None, ), # 0
13789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13790 
  )
13791 
 
13792 
  def __init__(self, success=None, ex=None,):
13793 
    self.success = success
13794 
    self.ex = ex
13795 
 
13796 
  def read(self, iprot):
13797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13799 
      return
13800 
    iprot.readStructBegin()
13801 
    while True:
13802 
      (fname, ftype, fid) = iprot.readFieldBegin()
13803 
      if ftype == TType.STOP:
13804 
        break
13805 
      if fid == 0:
13806 
        if ftype == TType.I64:
13807 
          self.success = iprot.readI64();
13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      elif fid == 1:
13811 
        if ftype == TType.STRUCT:
13812 
          self.ex = TransactionServiceException()
13813 
          self.ex.read(iprot)
13814 
        else:
13815 
          iprot.skip(ftype)
13816 
      else:
13817 
        iprot.skip(ftype)
13818 
      iprot.readFieldEnd()
13819 
    iprot.readStructEnd()
13820 
 
13821 
  def write(self, oprot):
13822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13824 
      return
13825 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13826 
    if self.success is not None:
2616 chandransh 13827 
      oprot.writeFieldBegin('success', TType.I64, 0)
13828 
      oprot.writeI64(self.success)
13829 
      oprot.writeFieldEnd()
3431 rajveer 13830 
    if self.ex is not None:
2616 chandransh 13831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13832 
      self.ex.write(oprot)
13833 
      oprot.writeFieldEnd()
13834 
    oprot.writeFieldStop()
13835 
    oprot.writeStructEnd()
13836 
 
3431 rajveer 13837 
  def validate(self):
13838 
    return
13839 
 
13840 
 
2616 chandransh 13841 
  def __repr__(self):
13842 
    L = ['%s=%r' % (key, value)
13843 
      for key, value in self.__dict__.iteritems()]
13844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13845 
 
13846 
  def __eq__(self, other):
13847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13848 
 
13849 
  def __ne__(self, other):
13850 
    return not (self == other)
13851 
 
13852 
class refundOrder_args:
13853 
  """
13854 
  Attributes:
13855 
   - orderId
3226 chandransh 13856 
   - refundedBy
13857 
   - reason
2616 chandransh 13858 
  """
13859 
 
13860 
  thrift_spec = (
13861 
    None, # 0
13862 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13863 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13864 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13865 
  )
13866 
 
3226 chandransh 13867 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13868 
    self.orderId = orderId
3226 chandransh 13869 
    self.refundedBy = refundedBy
13870 
    self.reason = reason
2616 chandransh 13871 
 
13872 
  def read(self, iprot):
13873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13875 
      return
13876 
    iprot.readStructBegin()
13877 
    while True:
13878 
      (fname, ftype, fid) = iprot.readFieldBegin()
13879 
      if ftype == TType.STOP:
13880 
        break
13881 
      if fid == 1:
13882 
        if ftype == TType.I64:
13883 
          self.orderId = iprot.readI64();
13884 
        else:
13885 
          iprot.skip(ftype)
3226 chandransh 13886 
      elif fid == 2:
13887 
        if ftype == TType.STRING:
13888 
          self.refundedBy = iprot.readString();
13889 
        else:
13890 
          iprot.skip(ftype)
13891 
      elif fid == 3:
13892 
        if ftype == TType.STRING:
13893 
          self.reason = iprot.readString();
13894 
        else:
13895 
          iprot.skip(ftype)
2616 chandransh 13896 
      else:
13897 
        iprot.skip(ftype)
13898 
      iprot.readFieldEnd()
13899 
    iprot.readStructEnd()
13900 
 
13901 
  def write(self, oprot):
13902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13904 
      return
13905 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13906 
    if self.orderId is not None:
2616 chandransh 13907 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13908 
      oprot.writeI64(self.orderId)
13909 
      oprot.writeFieldEnd()
3431 rajveer 13910 
    if self.refundedBy is not None:
3226 chandransh 13911 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13912 
      oprot.writeString(self.refundedBy)
13913 
      oprot.writeFieldEnd()
3431 rajveer 13914 
    if self.reason is not None:
3226 chandransh 13915 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13916 
      oprot.writeString(self.reason)
13917 
      oprot.writeFieldEnd()
2616 chandransh 13918 
    oprot.writeFieldStop()
13919 
    oprot.writeStructEnd()
13920 
 
3431 rajveer 13921 
  def validate(self):
13922 
    return
13923 
 
13924 
 
2616 chandransh 13925 
  def __repr__(self):
13926 
    L = ['%s=%r' % (key, value)
13927 
      for key, value in self.__dict__.iteritems()]
13928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13929 
 
13930 
  def __eq__(self, other):
13931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13932 
 
13933 
  def __ne__(self, other):
13934 
    return not (self == other)
13935 
 
13936 
class refundOrder_result:
13937 
  """
13938 
  Attributes:
13939 
   - success
13940 
   - ex
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    (0, TType.BOOL, 'success', None, None, ), # 0
13945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13946 
  )
13947 
 
13948 
  def __init__(self, success=None, ex=None,):
13949 
    self.success = success
13950 
    self.ex = ex
13951 
 
13952 
  def read(self, iprot):
13953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13955 
      return
13956 
    iprot.readStructBegin()
13957 
    while True:
13958 
      (fname, ftype, fid) = iprot.readFieldBegin()
13959 
      if ftype == TType.STOP:
13960 
        break
13961 
      if fid == 0:
13962 
        if ftype == TType.BOOL:
13963 
          self.success = iprot.readBool();
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      elif fid == 1:
13967 
        if ftype == TType.STRUCT:
13968 
          self.ex = TransactionServiceException()
13969 
          self.ex.read(iprot)
13970 
        else:
13971 
          iprot.skip(ftype)
13972 
      else:
13973 
        iprot.skip(ftype)
13974 
      iprot.readFieldEnd()
13975 
    iprot.readStructEnd()
13976 
 
13977 
  def write(self, oprot):
13978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13980 
      return
13981 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13982 
    if self.success is not None:
2616 chandransh 13983 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13984 
      oprot.writeBool(self.success)
13985 
      oprot.writeFieldEnd()
3431 rajveer 13986 
    if self.ex is not None:
2616 chandransh 13987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13988 
      self.ex.write(oprot)
13989 
      oprot.writeFieldEnd()
13990 
    oprot.writeFieldStop()
13991 
    oprot.writeStructEnd()
13992 
 
3431 rajveer 13993 
  def validate(self):
13994 
    return
13995 
 
13996 
 
2616 chandransh 13997 
  def __repr__(self):
13998 
    L = ['%s=%r' % (key, value)
13999 
      for key, value in self.__dict__.iteritems()]
14000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14001 
 
14002 
  def __eq__(self, other):
14003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14004 
 
14005 
  def __ne__(self, other):
14006 
    return not (self == other)
14007 
 
2690 chandransh 14008 
class getReturnOrders_args:
14009 
  """
14010 
  Attributes:
14011 
   - warehouseId
14012 
   - fromDate
14013 
   - toDate
14014 
  """
2616 chandransh 14015 
 
2690 chandransh 14016 
  thrift_spec = (
14017 
    None, # 0
14018 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14019 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14020 
    (3, TType.I64, 'toDate', None, None, ), # 3
14021 
  )
14022 
 
14023 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14024 
    self.warehouseId = warehouseId
14025 
    self.fromDate = fromDate
14026 
    self.toDate = toDate
14027 
 
14028 
  def read(self, iprot):
14029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14031 
      return
14032 
    iprot.readStructBegin()
14033 
    while True:
14034 
      (fname, ftype, fid) = iprot.readFieldBegin()
14035 
      if ftype == TType.STOP:
14036 
        break
14037 
      if fid == 1:
14038 
        if ftype == TType.I64:
14039 
          self.warehouseId = iprot.readI64();
14040 
        else:
14041 
          iprot.skip(ftype)
14042 
      elif fid == 2:
14043 
        if ftype == TType.I64:
14044 
          self.fromDate = iprot.readI64();
14045 
        else:
14046 
          iprot.skip(ftype)
14047 
      elif fid == 3:
14048 
        if ftype == TType.I64:
14049 
          self.toDate = iprot.readI64();
14050 
        else:
14051 
          iprot.skip(ftype)
14052 
      else:
14053 
        iprot.skip(ftype)
14054 
      iprot.readFieldEnd()
14055 
    iprot.readStructEnd()
14056 
 
14057 
  def write(self, oprot):
14058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14060 
      return
14061 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14062 
    if self.warehouseId is not None:
2690 chandransh 14063 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14064 
      oprot.writeI64(self.warehouseId)
14065 
      oprot.writeFieldEnd()
3431 rajveer 14066 
    if self.fromDate is not None:
2690 chandransh 14067 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14068 
      oprot.writeI64(self.fromDate)
14069 
      oprot.writeFieldEnd()
3431 rajveer 14070 
    if self.toDate is not None:
2690 chandransh 14071 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14072 
      oprot.writeI64(self.toDate)
14073 
      oprot.writeFieldEnd()
14074 
    oprot.writeFieldStop()
14075 
    oprot.writeStructEnd()
14076 
 
3431 rajveer 14077 
  def validate(self):
14078 
    return
14079 
 
14080 
 
2690 chandransh 14081 
  def __repr__(self):
14082 
    L = ['%s=%r' % (key, value)
14083 
      for key, value in self.__dict__.iteritems()]
14084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14085 
 
14086 
  def __eq__(self, other):
14087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14088 
 
14089 
  def __ne__(self, other):
14090 
    return not (self == other)
14091 
 
14092 
class getReturnOrders_result:
14093 
  """
14094 
  Attributes:
14095 
   - success
14096 
  """
14097 
 
14098 
  thrift_spec = (
14099 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14100 
  )
14101 
 
14102 
  def __init__(self, success=None,):
14103 
    self.success = success
14104 
 
14105 
  def read(self, iprot):
14106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14108 
      return
14109 
    iprot.readStructBegin()
14110 
    while True:
14111 
      (fname, ftype, fid) = iprot.readFieldBegin()
14112 
      if ftype == TType.STOP:
14113 
        break
14114 
      if fid == 0:
14115 
        if ftype == TType.LIST:
14116 
          self.success = []
4741 phani.kuma 14117 
          (_etype232, _size229) = iprot.readListBegin()
14118 
          for _i233 in xrange(_size229):
14119 
            _elem234 = ReturnOrder()
14120 
            _elem234.read(iprot)
14121 
            self.success.append(_elem234)
2690 chandransh 14122 
          iprot.readListEnd()
14123 
        else:
14124 
          iprot.skip(ftype)
14125 
      else:
14126 
        iprot.skip(ftype)
14127 
      iprot.readFieldEnd()
14128 
    iprot.readStructEnd()
14129 
 
14130 
  def write(self, oprot):
14131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14133 
      return
14134 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14135 
    if self.success is not None:
2690 chandransh 14136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 14138 
      for iter235 in self.success:
14139 
        iter235.write(oprot)
2690 chandransh 14140 
      oprot.writeListEnd()
14141 
      oprot.writeFieldEnd()
14142 
    oprot.writeFieldStop()
14143 
    oprot.writeStructEnd()
14144 
 
3431 rajveer 14145 
  def validate(self):
14146 
    return
14147 
 
14148 
 
2690 chandransh 14149 
  def __repr__(self):
14150 
    L = ['%s=%r' % (key, value)
14151 
      for key, value in self.__dict__.iteritems()]
14152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14153 
 
14154 
  def __eq__(self, other):
14155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14156 
 
14157 
  def __ne__(self, other):
14158 
    return not (self == other)
14159 
 
2700 chandransh 14160 
class getReturnOrder_args:
14161 
  """
14162 
  Attributes:
14163 
   - id
14164 
  """
14165 
 
14166 
  thrift_spec = (
14167 
    None, # 0
14168 
    (1, TType.I64, 'id', None, None, ), # 1
14169 
  )
14170 
 
14171 
  def __init__(self, id=None,):
14172 
    self.id = id
14173 
 
14174 
  def read(self, iprot):
14175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14177 
      return
14178 
    iprot.readStructBegin()
14179 
    while True:
14180 
      (fname, ftype, fid) = iprot.readFieldBegin()
14181 
      if ftype == TType.STOP:
14182 
        break
14183 
      if fid == 1:
14184 
        if ftype == TType.I64:
14185 
          self.id = iprot.readI64();
14186 
        else:
14187 
          iprot.skip(ftype)
14188 
      else:
14189 
        iprot.skip(ftype)
14190 
      iprot.readFieldEnd()
14191 
    iprot.readStructEnd()
14192 
 
14193 
  def write(self, oprot):
14194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14196 
      return
14197 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14198 
    if self.id is not None:
2700 chandransh 14199 
      oprot.writeFieldBegin('id', TType.I64, 1)
14200 
      oprot.writeI64(self.id)
14201 
      oprot.writeFieldEnd()
14202 
    oprot.writeFieldStop()
14203 
    oprot.writeStructEnd()
14204 
 
3431 rajveer 14205 
  def validate(self):
14206 
    return
14207 
 
14208 
 
2700 chandransh 14209 
  def __repr__(self):
14210 
    L = ['%s=%r' % (key, value)
14211 
      for key, value in self.__dict__.iteritems()]
14212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14213 
 
14214 
  def __eq__(self, other):
14215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14216 
 
14217 
  def __ne__(self, other):
14218 
    return not (self == other)
14219 
 
14220 
class getReturnOrder_result:
14221 
  """
14222 
  Attributes:
14223 
   - success
14224 
   - ex
14225 
  """
14226 
 
14227 
  thrift_spec = (
14228 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14230 
  )
14231 
 
14232 
  def __init__(self, success=None, ex=None,):
14233 
    self.success = success
14234 
    self.ex = ex
14235 
 
14236 
  def read(self, iprot):
14237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14239 
      return
14240 
    iprot.readStructBegin()
14241 
    while True:
14242 
      (fname, ftype, fid) = iprot.readFieldBegin()
14243 
      if ftype == TType.STOP:
14244 
        break
14245 
      if fid == 0:
14246 
        if ftype == TType.STRUCT:
14247 
          self.success = ReturnOrder()
14248 
          self.success.read(iprot)
14249 
        else:
14250 
          iprot.skip(ftype)
14251 
      elif fid == 1:
14252 
        if ftype == TType.STRUCT:
14253 
          self.ex = TransactionServiceException()
14254 
          self.ex.read(iprot)
14255 
        else:
14256 
          iprot.skip(ftype)
14257 
      else:
14258 
        iprot.skip(ftype)
14259 
      iprot.readFieldEnd()
14260 
    iprot.readStructEnd()
14261 
 
14262 
  def write(self, oprot):
14263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14265 
      return
14266 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14267 
    if self.success is not None:
2700 chandransh 14268 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14269 
      self.success.write(oprot)
14270 
      oprot.writeFieldEnd()
3431 rajveer 14271 
    if self.ex is not None:
2700 chandransh 14272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14273 
      self.ex.write(oprot)
14274 
      oprot.writeFieldEnd()
14275 
    oprot.writeFieldStop()
14276 
    oprot.writeStructEnd()
14277 
 
3431 rajveer 14278 
  def validate(self):
14279 
    return
14280 
 
14281 
 
2700 chandransh 14282 
  def __repr__(self):
14283 
    L = ['%s=%r' % (key, value)
14284 
      for key, value in self.__dict__.iteritems()]
14285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14286 
 
14287 
  def __eq__(self, other):
14288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14289 
 
14290 
  def __ne__(self, other):
14291 
    return not (self == other)
14292 
 
2690 chandransh 14293 
class processReturn_args:
14294 
  """
14295 
  Attributes:
14296 
   - returnOrderId
14297 
  """
14298 
 
14299 
  thrift_spec = (
14300 
    None, # 0
14301 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14302 
  )
14303 
 
14304 
  def __init__(self, returnOrderId=None,):
14305 
    self.returnOrderId = returnOrderId
14306 
 
14307 
  def read(self, iprot):
14308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14310 
      return
14311 
    iprot.readStructBegin()
14312 
    while True:
14313 
      (fname, ftype, fid) = iprot.readFieldBegin()
14314 
      if ftype == TType.STOP:
14315 
        break
14316 
      if fid == 1:
14317 
        if ftype == TType.I64:
14318 
          self.returnOrderId = iprot.readI64();
14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      else:
14322 
        iprot.skip(ftype)
14323 
      iprot.readFieldEnd()
14324 
    iprot.readStructEnd()
14325 
 
14326 
  def write(self, oprot):
14327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14329 
      return
14330 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14331 
    if self.returnOrderId is not None:
2690 chandransh 14332 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14333 
      oprot.writeI64(self.returnOrderId)
14334 
      oprot.writeFieldEnd()
14335 
    oprot.writeFieldStop()
14336 
    oprot.writeStructEnd()
14337 
 
3431 rajveer 14338 
  def validate(self):
14339 
    return
14340 
 
14341 
 
2690 chandransh 14342 
  def __repr__(self):
14343 
    L = ['%s=%r' % (key, value)
14344 
      for key, value in self.__dict__.iteritems()]
14345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14346 
 
14347 
  def __eq__(self, other):
14348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14349 
 
14350 
  def __ne__(self, other):
14351 
    return not (self == other)
14352 
 
14353 
class processReturn_result:
14354 
  """
14355 
  Attributes:
14356 
   - ex
14357 
  """
14358 
 
14359 
  thrift_spec = (
14360 
    None, # 0
14361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14362 
  )
14363 
 
14364 
  def __init__(self, ex=None,):
14365 
    self.ex = ex
14366 
 
14367 
  def read(self, iprot):
14368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14370 
      return
14371 
    iprot.readStructBegin()
14372 
    while True:
14373 
      (fname, ftype, fid) = iprot.readFieldBegin()
14374 
      if ftype == TType.STOP:
14375 
        break
14376 
      if fid == 1:
14377 
        if ftype == TType.STRUCT:
14378 
          self.ex = TransactionServiceException()
14379 
          self.ex.read(iprot)
14380 
        else:
14381 
          iprot.skip(ftype)
14382 
      else:
14383 
        iprot.skip(ftype)
14384 
      iprot.readFieldEnd()
14385 
    iprot.readStructEnd()
14386 
 
14387 
  def write(self, oprot):
14388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14390 
      return
14391 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14392 
    if self.ex is not None:
2690 chandransh 14393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14394 
      self.ex.write(oprot)
14395 
      oprot.writeFieldEnd()
14396 
    oprot.writeFieldStop()
14397 
    oprot.writeStructEnd()
14398 
 
3431 rajveer 14399 
  def validate(self):
14400 
    return
14401 
 
14402 
 
2690 chandransh 14403 
  def __repr__(self):
14404 
    L = ['%s=%r' % (key, value)
14405 
      for key, value in self.__dict__.iteritems()]
14406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14407 
 
14408 
  def __eq__(self, other):
14409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14410 
 
14411 
  def __ne__(self, other):
14412 
    return not (self == other)
14413 
 
3451 chandransh 14414 
class updateWeight_args:
14415 
  """
14416 
  Attributes:
14417 
   - orderId
14418 
   - weight
14419 
  """
14420 
 
14421 
  thrift_spec = (
14422 
    None, # 0
14423 
    (1, TType.I64, 'orderId', None, None, ), # 1
14424 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14425 
  )
14426 
 
14427 
  def __init__(self, orderId=None, weight=None,):
14428 
    self.orderId = orderId
14429 
    self.weight = weight
14430 
 
14431 
  def read(self, iprot):
14432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14434 
      return
14435 
    iprot.readStructBegin()
14436 
    while True:
14437 
      (fname, ftype, fid) = iprot.readFieldBegin()
14438 
      if ftype == TType.STOP:
14439 
        break
14440 
      if fid == 1:
14441 
        if ftype == TType.I64:
14442 
          self.orderId = iprot.readI64();
14443 
        else:
14444 
          iprot.skip(ftype)
14445 
      elif fid == 2:
14446 
        if ftype == TType.DOUBLE:
14447 
          self.weight = iprot.readDouble();
14448 
        else:
14449 
          iprot.skip(ftype)
14450 
      else:
14451 
        iprot.skip(ftype)
14452 
      iprot.readFieldEnd()
14453 
    iprot.readStructEnd()
14454 
 
14455 
  def write(self, oprot):
14456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14458 
      return
14459 
    oprot.writeStructBegin('updateWeight_args')
14460 
    if self.orderId is not None:
14461 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14462 
      oprot.writeI64(self.orderId)
14463 
      oprot.writeFieldEnd()
14464 
    if self.weight is not None:
14465 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14466 
      oprot.writeDouble(self.weight)
14467 
      oprot.writeFieldEnd()
14468 
    oprot.writeFieldStop()
14469 
    oprot.writeStructEnd()
14470 
 
14471 
  def validate(self):
14472 
    return
14473 
 
14474 
 
14475 
  def __repr__(self):
14476 
    L = ['%s=%r' % (key, value)
14477 
      for key, value in self.__dict__.iteritems()]
14478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14479 
 
14480 
  def __eq__(self, other):
14481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14482 
 
14483 
  def __ne__(self, other):
14484 
    return not (self == other)
14485 
 
14486 
class updateWeight_result:
14487 
  """
14488 
  Attributes:
14489 
   - success
14490 
   - ex
14491 
  """
14492 
 
14493 
  thrift_spec = (
14494 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14496 
  )
14497 
 
14498 
  def __init__(self, success=None, ex=None,):
14499 
    self.success = success
14500 
    self.ex = ex
14501 
 
14502 
  def read(self, iprot):
14503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14505 
      return
14506 
    iprot.readStructBegin()
14507 
    while True:
14508 
      (fname, ftype, fid) = iprot.readFieldBegin()
14509 
      if ftype == TType.STOP:
14510 
        break
14511 
      if fid == 0:
14512 
        if ftype == TType.STRUCT:
14513 
          self.success = Order()
14514 
          self.success.read(iprot)
14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      elif fid == 1:
14518 
        if ftype == TType.STRUCT:
14519 
          self.ex = TransactionServiceException()
14520 
          self.ex.read(iprot)
14521 
        else:
14522 
          iprot.skip(ftype)
14523 
      else:
14524 
        iprot.skip(ftype)
14525 
      iprot.readFieldEnd()
14526 
    iprot.readStructEnd()
14527 
 
14528 
  def write(self, oprot):
14529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14531 
      return
14532 
    oprot.writeStructBegin('updateWeight_result')
14533 
    if self.success is not None:
14534 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14535 
      self.success.write(oprot)
14536 
      oprot.writeFieldEnd()
14537 
    if self.ex is not None:
14538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14539 
      self.ex.write(oprot)
14540 
      oprot.writeFieldEnd()
14541 
    oprot.writeFieldStop()
14542 
    oprot.writeStructEnd()
14543 
 
14544 
  def validate(self):
14545 
    return
14546 
 
14547 
 
14548 
  def __repr__(self):
14549 
    L = ['%s=%r' % (key, value)
14550 
      for key, value in self.__dict__.iteritems()]
14551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14552 
 
14553 
  def __eq__(self, other):
14554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14555 
 
14556 
  def __ne__(self, other):
14557 
    return not (self == other)
3469 chandransh 14558 
 
14559 
class changeItem_args:
14560 
  """
14561 
  Attributes:
14562 
   - orderId
14563 
   - itemId
14564 
  """
14565 
 
14566 
  thrift_spec = (
14567 
    None, # 0
14568 
    (1, TType.I64, 'orderId', None, None, ), # 1
14569 
    (2, TType.I64, 'itemId', None, None, ), # 2
14570 
  )
14571 
 
14572 
  def __init__(self, orderId=None, itemId=None,):
14573 
    self.orderId = orderId
14574 
    self.itemId = itemId
14575 
 
14576 
  def read(self, iprot):
14577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14579 
      return
14580 
    iprot.readStructBegin()
14581 
    while True:
14582 
      (fname, ftype, fid) = iprot.readFieldBegin()
14583 
      if ftype == TType.STOP:
14584 
        break
14585 
      if fid == 1:
14586 
        if ftype == TType.I64:
14587 
          self.orderId = iprot.readI64();
14588 
        else:
14589 
          iprot.skip(ftype)
14590 
      elif fid == 2:
14591 
        if ftype == TType.I64:
14592 
          self.itemId = iprot.readI64();
14593 
        else:
14594 
          iprot.skip(ftype)
14595 
      else:
14596 
        iprot.skip(ftype)
14597 
      iprot.readFieldEnd()
14598 
    iprot.readStructEnd()
14599 
 
14600 
  def write(self, oprot):
14601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14603 
      return
14604 
    oprot.writeStructBegin('changeItem_args')
14605 
    if self.orderId is not None:
14606 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14607 
      oprot.writeI64(self.orderId)
14608 
      oprot.writeFieldEnd()
14609 
    if self.itemId is not None:
14610 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14611 
      oprot.writeI64(self.itemId)
14612 
      oprot.writeFieldEnd()
14613 
    oprot.writeFieldStop()
14614 
    oprot.writeStructEnd()
14615 
 
14616 
  def validate(self):
14617 
    return
14618 
 
14619 
 
14620 
  def __repr__(self):
14621 
    L = ['%s=%r' % (key, value)
14622 
      for key, value in self.__dict__.iteritems()]
14623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14624 
 
14625 
  def __eq__(self, other):
14626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14627 
 
14628 
  def __ne__(self, other):
14629 
    return not (self == other)
14630 
 
14631 
class changeItem_result:
14632 
  """
14633 
  Attributes:
14634 
   - success
14635 
   - ex
14636 
  """
14637 
 
14638 
  thrift_spec = (
14639 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14641 
  )
14642 
 
14643 
  def __init__(self, success=None, ex=None,):
14644 
    self.success = success
14645 
    self.ex = ex
14646 
 
14647 
  def read(self, iprot):
14648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14650 
      return
14651 
    iprot.readStructBegin()
14652 
    while True:
14653 
      (fname, ftype, fid) = iprot.readFieldBegin()
14654 
      if ftype == TType.STOP:
14655 
        break
14656 
      if fid == 0:
14657 
        if ftype == TType.STRUCT:
14658 
          self.success = Order()
14659 
          self.success.read(iprot)
14660 
        else:
14661 
          iprot.skip(ftype)
14662 
      elif fid == 1:
14663 
        if ftype == TType.STRUCT:
14664 
          self.ex = TransactionServiceException()
14665 
          self.ex.read(iprot)
14666 
        else:
14667 
          iprot.skip(ftype)
14668 
      else:
14669 
        iprot.skip(ftype)
14670 
      iprot.readFieldEnd()
14671 
    iprot.readStructEnd()
14672 
 
14673 
  def write(self, oprot):
14674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14676 
      return
14677 
    oprot.writeStructBegin('changeItem_result')
14678 
    if self.success is not None:
14679 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14680 
      self.success.write(oprot)
14681 
      oprot.writeFieldEnd()
14682 
    if self.ex is not None:
14683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14684 
      self.ex.write(oprot)
14685 
      oprot.writeFieldEnd()
14686 
    oprot.writeFieldStop()
14687 
    oprot.writeStructEnd()
14688 
 
14689 
  def validate(self):
14690 
    return
14691 
 
14692 
 
14693 
  def __repr__(self):
14694 
    L = ['%s=%r' % (key, value)
14695 
      for key, value in self.__dict__.iteritems()]
14696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14697 
 
14698 
  def __eq__(self, other):
14699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14700 
 
14701 
  def __ne__(self, other):
14702 
    return not (self == other)
14703 
 
14704 
class shiftToWarehouse_args:
14705 
  """
14706 
  Attributes:
14707 
   - orderId
14708 
   - warehouseId
14709 
  """
14710 
 
14711 
  thrift_spec = (
14712 
    None, # 0
14713 
    (1, TType.I64, 'orderId', None, None, ), # 1
14714 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14715 
  )
14716 
 
14717 
  def __init__(self, orderId=None, warehouseId=None,):
14718 
    self.orderId = orderId
14719 
    self.warehouseId = warehouseId
14720 
 
14721 
  def read(self, iprot):
14722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14724 
      return
14725 
    iprot.readStructBegin()
14726 
    while True:
14727 
      (fname, ftype, fid) = iprot.readFieldBegin()
14728 
      if ftype == TType.STOP:
14729 
        break
14730 
      if fid == 1:
14731 
        if ftype == TType.I64:
14732 
          self.orderId = iprot.readI64();
14733 
        else:
14734 
          iprot.skip(ftype)
14735 
      elif fid == 2:
14736 
        if ftype == TType.I64:
14737 
          self.warehouseId = iprot.readI64();
14738 
        else:
14739 
          iprot.skip(ftype)
14740 
      else:
14741 
        iprot.skip(ftype)
14742 
      iprot.readFieldEnd()
14743 
    iprot.readStructEnd()
14744 
 
14745 
  def write(self, oprot):
14746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14748 
      return
14749 
    oprot.writeStructBegin('shiftToWarehouse_args')
14750 
    if self.orderId is not None:
14751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14752 
      oprot.writeI64(self.orderId)
14753 
      oprot.writeFieldEnd()
14754 
    if self.warehouseId is not None:
14755 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14756 
      oprot.writeI64(self.warehouseId)
14757 
      oprot.writeFieldEnd()
14758 
    oprot.writeFieldStop()
14759 
    oprot.writeStructEnd()
14760 
 
14761 
  def validate(self):
14762 
    return
14763 
 
14764 
 
14765 
  def __repr__(self):
14766 
    L = ['%s=%r' % (key, value)
14767 
      for key, value in self.__dict__.iteritems()]
14768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14769 
 
14770 
  def __eq__(self, other):
14771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14772 
 
14773 
  def __ne__(self, other):
14774 
    return not (self == other)
14775 
 
14776 
class shiftToWarehouse_result:
14777 
  """
14778 
  Attributes:
14779 
   - success
14780 
   - ex
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14786 
  )
14787 
 
14788 
  def __init__(self, success=None, ex=None,):
14789 
    self.success = success
14790 
    self.ex = ex
14791 
 
14792 
  def read(self, iprot):
14793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14795 
      return
14796 
    iprot.readStructBegin()
14797 
    while True:
14798 
      (fname, ftype, fid) = iprot.readFieldBegin()
14799 
      if ftype == TType.STOP:
14800 
        break
14801 
      if fid == 0:
14802 
        if ftype == TType.STRUCT:
14803 
          self.success = Order()
14804 
          self.success.read(iprot)
14805 
        else:
14806 
          iprot.skip(ftype)
14807 
      elif fid == 1:
14808 
        if ftype == TType.STRUCT:
14809 
          self.ex = TransactionServiceException()
14810 
          self.ex.read(iprot)
14811 
        else:
14812 
          iprot.skip(ftype)
14813 
      else:
14814 
        iprot.skip(ftype)
14815 
      iprot.readFieldEnd()
14816 
    iprot.readStructEnd()
14817 
 
14818 
  def write(self, oprot):
14819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14821 
      return
14822 
    oprot.writeStructBegin('shiftToWarehouse_result')
14823 
    if self.success is not None:
14824 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14825 
      self.success.write(oprot)
14826 
      oprot.writeFieldEnd()
14827 
    if self.ex is not None:
14828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14829 
      self.ex.write(oprot)
14830 
      oprot.writeFieldEnd()
14831 
    oprot.writeFieldStop()
14832 
    oprot.writeStructEnd()
14833 
 
14834 
  def validate(self):
14835 
    return
14836 
 
14837 
 
14838 
  def __repr__(self):
14839 
    L = ['%s=%r' % (key, value)
14840 
      for key, value in self.__dict__.iteritems()]
14841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14842 
 
14843 
  def __eq__(self, other):
14844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14845 
 
14846 
  def __ne__(self, other):
14847 
    return not (self == other)
3553 chandransh 14848 
 
14849 
class addDelayReason_args:
14850 
  """
14851 
  Attributes:
14852 
   - orderId
14853 
   - delayReason
3986 chandransh 14854 
   - furtherDelay
4647 rajveer 14855 
   - delayReasonText
3553 chandransh 14856 
  """
14857 
 
14858 
  thrift_spec = (
14859 
    None, # 0
14860 
    (1, TType.I64, 'orderId', None, None, ), # 1
14861 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14862 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14863 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14864 
  )
14865 
 
4647 rajveer 14866 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14867 
    self.orderId = orderId
14868 
    self.delayReason = delayReason
3986 chandransh 14869 
    self.furtherDelay = furtherDelay
4647 rajveer 14870 
    self.delayReasonText = delayReasonText
3553 chandransh 14871 
 
14872 
  def read(self, iprot):
14873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14875 
      return
14876 
    iprot.readStructBegin()
14877 
    while True:
14878 
      (fname, ftype, fid) = iprot.readFieldBegin()
14879 
      if ftype == TType.STOP:
14880 
        break
14881 
      if fid == 1:
14882 
        if ftype == TType.I64:
14883 
          self.orderId = iprot.readI64();
14884 
        else:
14885 
          iprot.skip(ftype)
14886 
      elif fid == 2:
14887 
        if ftype == TType.I32:
14888 
          self.delayReason = iprot.readI32();
14889 
        else:
14890 
          iprot.skip(ftype)
3986 chandransh 14891 
      elif fid == 3:
14892 
        if ftype == TType.I64:
14893 
          self.furtherDelay = iprot.readI64();
14894 
        else:
14895 
          iprot.skip(ftype)
4647 rajveer 14896 
      elif fid == 4:
14897 
        if ftype == TType.STRING:
14898 
          self.delayReasonText = iprot.readString();
14899 
        else:
14900 
          iprot.skip(ftype)
3553 chandransh 14901 
      else:
14902 
        iprot.skip(ftype)
14903 
      iprot.readFieldEnd()
14904 
    iprot.readStructEnd()
14905 
 
14906 
  def write(self, oprot):
14907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14909 
      return
14910 
    oprot.writeStructBegin('addDelayReason_args')
14911 
    if self.orderId is not None:
14912 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14913 
      oprot.writeI64(self.orderId)
14914 
      oprot.writeFieldEnd()
14915 
    if self.delayReason is not None:
14916 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14917 
      oprot.writeI32(self.delayReason)
14918 
      oprot.writeFieldEnd()
3986 chandransh 14919 
    if self.furtherDelay is not None:
14920 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14921 
      oprot.writeI64(self.furtherDelay)
14922 
      oprot.writeFieldEnd()
4647 rajveer 14923 
    if self.delayReasonText is not None:
14924 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14925 
      oprot.writeString(self.delayReasonText)
14926 
      oprot.writeFieldEnd()
3553 chandransh 14927 
    oprot.writeFieldStop()
14928 
    oprot.writeStructEnd()
14929 
 
14930 
  def validate(self):
14931 
    return
14932 
 
14933 
 
14934 
  def __repr__(self):
14935 
    L = ['%s=%r' % (key, value)
14936 
      for key, value in self.__dict__.iteritems()]
14937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14938 
 
14939 
  def __eq__(self, other):
14940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14941 
 
14942 
  def __ne__(self, other):
14943 
    return not (self == other)
14944 
 
14945 
class addDelayReason_result:
14946 
  """
14947 
  Attributes:
14948 
   - success
14949 
   - ex
14950 
  """
14951 
 
14952 
  thrift_spec = (
14953 
    (0, TType.BOOL, 'success', None, None, ), # 0
14954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14955 
  )
14956 
 
14957 
  def __init__(self, success=None, ex=None,):
14958 
    self.success = success
14959 
    self.ex = ex
14960 
 
14961 
  def read(self, iprot):
14962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14964 
      return
14965 
    iprot.readStructBegin()
14966 
    while True:
14967 
      (fname, ftype, fid) = iprot.readFieldBegin()
14968 
      if ftype == TType.STOP:
14969 
        break
14970 
      if fid == 0:
14971 
        if ftype == TType.BOOL:
14972 
          self.success = iprot.readBool();
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      elif fid == 1:
14976 
        if ftype == TType.STRUCT:
14977 
          self.ex = TransactionServiceException()
14978 
          self.ex.read(iprot)
14979 
        else:
14980 
          iprot.skip(ftype)
14981 
      else:
14982 
        iprot.skip(ftype)
14983 
      iprot.readFieldEnd()
14984 
    iprot.readStructEnd()
14985 
 
14986 
  def write(self, oprot):
14987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14989 
      return
14990 
    oprot.writeStructBegin('addDelayReason_result')
14991 
    if self.success is not None:
14992 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14993 
      oprot.writeBool(self.success)
14994 
      oprot.writeFieldEnd()
14995 
    if self.ex is not None:
14996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14997 
      self.ex.write(oprot)
14998 
      oprot.writeFieldEnd()
14999 
    oprot.writeFieldStop()
15000 
    oprot.writeStructEnd()
15001 
 
15002 
  def validate(self):
15003 
    return
15004 
 
15005 
 
15006 
  def __repr__(self):
15007 
    L = ['%s=%r' % (key, value)
15008 
      for key, value in self.__dict__.iteritems()]
15009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15010 
 
15011 
  def __eq__(self, other):
15012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15013 
 
15014 
  def __ne__(self, other):
15015 
    return not (self == other)
3956 chandransh 15016 
 
15017 
class reconcileCodCollection_args:
15018 
  """
15019 
  Attributes:
15020 
   - collectedAmountMap
15021 
   - xferBy
15022 
   - xferTxnId
15023 
   - xferDate
15024 
  """
15025 
 
15026 
  thrift_spec = (
15027 
    None, # 0
15028 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15029 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15030 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15031 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15032 
  )
15033 
 
15034 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15035 
    self.collectedAmountMap = collectedAmountMap
15036 
    self.xferBy = xferBy
15037 
    self.xferTxnId = xferTxnId
15038 
    self.xferDate = xferDate
15039 
 
15040 
  def read(self, iprot):
15041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15043 
      return
15044 
    iprot.readStructBegin()
15045 
    while True:
15046 
      (fname, ftype, fid) = iprot.readFieldBegin()
15047 
      if ftype == TType.STOP:
15048 
        break
15049 
      if fid == 1:
15050 
        if ftype == TType.MAP:
15051 
          self.collectedAmountMap = {}
4757 mandeep.dh 15052 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
15053 
          for _i240 in xrange(_size236):
15054 
            _key241 = iprot.readString();
15055 
            _val242 = iprot.readDouble();
15056 
            self.collectedAmountMap[_key241] = _val242
3956 chandransh 15057 
          iprot.readMapEnd()
15058 
        else:
15059 
          iprot.skip(ftype)
15060 
      elif fid == 2:
15061 
        if ftype == TType.STRING:
15062 
          self.xferBy = iprot.readString();
15063 
        else:
15064 
          iprot.skip(ftype)
15065 
      elif fid == 3:
15066 
        if ftype == TType.STRING:
15067 
          self.xferTxnId = iprot.readString();
15068 
        else:
15069 
          iprot.skip(ftype)
15070 
      elif fid == 4:
15071 
        if ftype == TType.I64:
15072 
          self.xferDate = iprot.readI64();
15073 
        else:
15074 
          iprot.skip(ftype)
15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
15084 
    oprot.writeStructBegin('reconcileCodCollection_args')
15085 
    if self.collectedAmountMap is not None:
15086 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15087 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4757 mandeep.dh 15088 
      for kiter243,viter244 in self.collectedAmountMap.items():
15089 
        oprot.writeString(kiter243)
15090 
        oprot.writeDouble(viter244)
3956 chandransh 15091 
      oprot.writeMapEnd()
15092 
      oprot.writeFieldEnd()
15093 
    if self.xferBy is not None:
15094 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15095 
      oprot.writeString(self.xferBy)
15096 
      oprot.writeFieldEnd()
15097 
    if self.xferTxnId is not None:
15098 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15099 
      oprot.writeString(self.xferTxnId)
15100 
      oprot.writeFieldEnd()
15101 
    if self.xferDate is not None:
15102 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15103 
      oprot.writeI64(self.xferDate)
15104 
      oprot.writeFieldEnd()
15105 
    oprot.writeFieldStop()
15106 
    oprot.writeStructEnd()
15107 
 
15108 
  def validate(self):
15109 
    return
15110 
 
15111 
 
15112 
  def __repr__(self):
15113 
    L = ['%s=%r' % (key, value)
15114 
      for key, value in self.__dict__.iteritems()]
15115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15116 
 
15117 
  def __eq__(self, other):
15118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15119 
 
15120 
  def __ne__(self, other):
15121 
    return not (self == other)
15122 
 
15123 
class reconcileCodCollection_result:
15124 
  """
15125 
  Attributes:
15126 
   - success
15127 
   - ex
15128 
  """
15129 
 
15130 
  thrift_spec = (
15131 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15133 
  )
15134 
 
15135 
  def __init__(self, success=None, ex=None,):
15136 
    self.success = success
15137 
    self.ex = ex
15138 
 
15139 
  def read(self, iprot):
15140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15142 
      return
15143 
    iprot.readStructBegin()
15144 
    while True:
15145 
      (fname, ftype, fid) = iprot.readFieldBegin()
15146 
      if ftype == TType.STOP:
15147 
        break
15148 
      if fid == 0:
15149 
        if ftype == TType.MAP:
15150 
          self.success = {}
4757 mandeep.dh 15151 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
15152 
          for _i249 in xrange(_size245):
15153 
            _key250 = iprot.readString();
15154 
            _val251 = iprot.readString();
15155 
            self.success[_key250] = _val251
3956 chandransh 15156 
          iprot.readMapEnd()
15157 
        else:
15158 
          iprot.skip(ftype)
15159 
      elif fid == 1:
15160 
        if ftype == TType.STRUCT:
15161 
          self.ex = TransactionServiceException()
15162 
          self.ex.read(iprot)
15163 
        else:
15164 
          iprot.skip(ftype)
15165 
      else:
15166 
        iprot.skip(ftype)
15167 
      iprot.readFieldEnd()
15168 
    iprot.readStructEnd()
15169 
 
15170 
  def write(self, oprot):
15171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15173 
      return
15174 
    oprot.writeStructBegin('reconcileCodCollection_result')
15175 
    if self.success is not None:
15176 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15177 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4757 mandeep.dh 15178 
      for kiter252,viter253 in self.success.items():
15179 
        oprot.writeString(kiter252)
15180 
        oprot.writeString(viter253)
3956 chandransh 15181 
      oprot.writeMapEnd()
15182 
      oprot.writeFieldEnd()
15183 
    if self.ex is not None:
15184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15185 
      self.ex.write(oprot)
15186 
      oprot.writeFieldEnd()
15187 
    oprot.writeFieldStop()
15188 
    oprot.writeStructEnd()
15189 
 
15190 
  def validate(self):
15191 
    return
15192 
 
15193 
 
15194 
  def __repr__(self):
15195 
    L = ['%s=%r' % (key, value)
15196 
      for key, value in self.__dict__.iteritems()]
15197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15198 
 
15199 
  def __eq__(self, other):
15200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15201 
 
15202 
  def __ne__(self, other):
15203 
    return not (self == other)
4008 mandeep.dh 15204 
 
15205 
class getTransactionsRequiringExtraProcessing_args:
15206 
  """
15207 
  Attributes:
15208 
   - category
15209 
  """
15210 
 
15211 
  thrift_spec = (
15212 
    None, # 0
15213 
    (1, TType.I32, 'category', None, None, ), # 1
15214 
  )
15215 
 
15216 
  def __init__(self, category=None,):
15217 
    self.category = category
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 1:
15229 
        if ftype == TType.I32:
15230 
          self.category = iprot.readI32();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15243 
    if self.category is not None:
15244 
      oprot.writeFieldBegin('category', TType.I32, 1)
15245 
      oprot.writeI32(self.category)
15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
15264 
 
15265 
class getTransactionsRequiringExtraProcessing_result:
15266 
  """
15267 
  Attributes:
15268 
   - success
15269 
  """
15270 
 
15271 
  thrift_spec = (
15272 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15273 
  )
15274 
 
15275 
  def __init__(self, success=None,):
15276 
    self.success = success
15277 
 
15278 
  def read(self, iprot):
15279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15281 
      return
15282 
    iprot.readStructBegin()
15283 
    while True:
15284 
      (fname, ftype, fid) = iprot.readFieldBegin()
15285 
      if ftype == TType.STOP:
15286 
        break
15287 
      if fid == 0:
15288 
        if ftype == TType.LIST:
15289 
          self.success = []
4757 mandeep.dh 15290 
          (_etype257, _size254) = iprot.readListBegin()
15291 
          for _i258 in xrange(_size254):
15292 
            _elem259 = iprot.readI64();
15293 
            self.success.append(_elem259)
4008 mandeep.dh 15294 
          iprot.readListEnd()
15295 
        else:
15296 
          iprot.skip(ftype)
15297 
      else:
15298 
        iprot.skip(ftype)
15299 
      iprot.readFieldEnd()
15300 
    iprot.readStructEnd()
15301 
 
15302 
  def write(self, oprot):
15303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15305 
      return
15306 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15307 
    if self.success is not None:
15308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15309 
      oprot.writeListBegin(TType.I64, len(self.success))
4757 mandeep.dh 15310 
      for iter260 in self.success:
15311 
        oprot.writeI64(iter260)
4008 mandeep.dh 15312 
      oprot.writeListEnd()
15313 
      oprot.writeFieldEnd()
15314 
    oprot.writeFieldStop()
15315 
    oprot.writeStructEnd()
15316 
 
15317 
  def validate(self):
15318 
    return
15319 
 
15320 
 
15321 
  def __repr__(self):
15322 
    L = ['%s=%r' % (key, value)
15323 
      for key, value in self.__dict__.iteritems()]
15324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15325 
 
15326 
  def __eq__(self, other):
15327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15328 
 
15329 
  def __ne__(self, other):
15330 
    return not (self == other)
15331 
 
15332 
class markTransactionAsProcessed_args:
15333 
  """
15334 
  Attributes:
15335 
   - transactionId
15336 
   - category
15337 
  """
15338 
 
15339 
  thrift_spec = (
15340 
    None, # 0
15341 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15342 
    (2, TType.I32, 'category', None, None, ), # 2
15343 
  )
15344 
 
15345 
  def __init__(self, transactionId=None, category=None,):
15346 
    self.transactionId = transactionId
15347 
    self.category = category
15348 
 
15349 
  def read(self, iprot):
15350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15352 
      return
15353 
    iprot.readStructBegin()
15354 
    while True:
15355 
      (fname, ftype, fid) = iprot.readFieldBegin()
15356 
      if ftype == TType.STOP:
15357 
        break
15358 
      if fid == 1:
15359 
        if ftype == TType.I64:
15360 
          self.transactionId = iprot.readI64();
15361 
        else:
15362 
          iprot.skip(ftype)
15363 
      elif fid == 2:
15364 
        if ftype == TType.I32:
15365 
          self.category = iprot.readI32();
15366 
        else:
15367 
          iprot.skip(ftype)
15368 
      else:
15369 
        iprot.skip(ftype)
15370 
      iprot.readFieldEnd()
15371 
    iprot.readStructEnd()
15372 
 
15373 
  def write(self, oprot):
15374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15376 
      return
15377 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15378 
    if self.transactionId is not None:
15379 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15380 
      oprot.writeI64(self.transactionId)
15381 
      oprot.writeFieldEnd()
15382 
    if self.category is not None:
15383 
      oprot.writeFieldBegin('category', TType.I32, 2)
15384 
      oprot.writeI32(self.category)
15385 
      oprot.writeFieldEnd()
15386 
    oprot.writeFieldStop()
15387 
    oprot.writeStructEnd()
15388 
 
15389 
  def validate(self):
15390 
    return
15391 
 
15392 
 
15393 
  def __repr__(self):
15394 
    L = ['%s=%r' % (key, value)
15395 
      for key, value in self.__dict__.iteritems()]
15396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15397 
 
15398 
  def __eq__(self, other):
15399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15400 
 
15401 
  def __ne__(self, other):
15402 
    return not (self == other)
15403 
 
15404 
class markTransactionAsProcessed_result:
15405 
 
15406 
  thrift_spec = (
15407 
  )
15408 
 
15409 
  def read(self, iprot):
15410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15412 
      return
15413 
    iprot.readStructBegin()
15414 
    while True:
15415 
      (fname, ftype, fid) = iprot.readFieldBegin()
15416 
      if ftype == TType.STOP:
15417 
        break
15418 
      else:
15419 
        iprot.skip(ftype)
15420 
      iprot.readFieldEnd()
15421 
    iprot.readStructEnd()
15422 
 
15423 
  def write(self, oprot):
15424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15426 
      return
15427 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15428 
    oprot.writeFieldStop()
15429 
    oprot.writeStructEnd()
15430 
 
15431 
  def validate(self):
15432 
    return
15433 
 
15434 
 
15435 
  def __repr__(self):
15436 
    L = ['%s=%r' % (key, value)
15437 
      for key, value in self.__dict__.iteritems()]
15438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15439 
 
15440 
  def __eq__(self, other):
15441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15442 
 
15443 
  def __ne__(self, other):
15444 
    return not (self == other)
4018 chandransh 15445 
 
15446 
class getItemWiseRiskyOrdersCount_args:
15447 
 
15448 
  thrift_spec = (
15449 
  )
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15470 
    oprot.writeFieldStop()
15471 
    oprot.writeStructEnd()
15472 
 
15473 
  def validate(self):
15474 
    return
15475 
 
15476 
 
15477 
  def __repr__(self):
15478 
    L = ['%s=%r' % (key, value)
15479 
      for key, value in self.__dict__.iteritems()]
15480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15481 
 
15482 
  def __eq__(self, other):
15483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15484 
 
15485 
  def __ne__(self, other):
15486 
    return not (self == other)
15487 
 
15488 
class getItemWiseRiskyOrdersCount_result:
15489 
  """
15490 
  Attributes:
15491 
   - success
15492 
  """
15493 
 
15494 
  thrift_spec = (
15495 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15496 
  )
15497 
 
15498 
  def __init__(self, success=None,):
15499 
    self.success = success
15500 
 
15501 
  def read(self, iprot):
15502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15504 
      return
15505 
    iprot.readStructBegin()
15506 
    while True:
15507 
      (fname, ftype, fid) = iprot.readFieldBegin()
15508 
      if ftype == TType.STOP:
15509 
        break
15510 
      if fid == 0:
15511 
        if ftype == TType.MAP:
15512 
          self.success = {}
4757 mandeep.dh 15513 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15514 
          for _i265 in xrange(_size261):
15515 
            _key266 = iprot.readI64();
15516 
            _val267 = iprot.readI64();
15517 
            self.success[_key266] = _val267
4018 chandransh 15518 
          iprot.readMapEnd()
15519 
        else:
15520 
          iprot.skip(ftype)
15521 
      else:
15522 
        iprot.skip(ftype)
15523 
      iprot.readFieldEnd()
15524 
    iprot.readStructEnd()
15525 
 
15526 
  def write(self, oprot):
15527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15529 
      return
15530 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15531 
    if self.success is not None:
15532 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15533 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4757 mandeep.dh 15534 
      for kiter268,viter269 in self.success.items():
15535 
        oprot.writeI64(kiter268)
15536 
        oprot.writeI64(viter269)
4018 chandransh 15537 
      oprot.writeMapEnd()
15538 
      oprot.writeFieldEnd()
15539 
    oprot.writeFieldStop()
15540 
    oprot.writeStructEnd()
15541 
 
15542 
  def validate(self):
15543 
    return
15544 
 
15545 
 
15546 
  def __repr__(self):
15547 
    L = ['%s=%r' % (key, value)
15548 
      for key, value in self.__dict__.iteritems()]
15549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15550 
 
15551 
  def __eq__(self, other):
15552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15553 
 
15554 
  def __ne__(self, other):
15555 
    return not (self == other)
4247 rajveer 15556 
 
4295 varun.gupt 15557 
class getOrdersForItemIds_args:
15558 
  """
15559 
  Attributes:
15560 
   - itemIds
15561 
  """
15562 
 
15563 
  thrift_spec = (
15564 
    None, # 0
15565 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15566 
  )
15567 
 
15568 
  def __init__(self, itemIds=None,):
15569 
    self.itemIds = itemIds
15570 
 
15571 
  def read(self, iprot):
15572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15574 
      return
15575 
    iprot.readStructBegin()
15576 
    while True:
15577 
      (fname, ftype, fid) = iprot.readFieldBegin()
15578 
      if ftype == TType.STOP:
15579 
        break
15580 
      if fid == 1:
15581 
        if ftype == TType.LIST:
15582 
          self.itemIds = []
4757 mandeep.dh 15583 
          (_etype273, _size270) = iprot.readListBegin()
15584 
          for _i274 in xrange(_size270):
15585 
            _elem275 = iprot.readI64();
15586 
            self.itemIds.append(_elem275)
4295 varun.gupt 15587 
          iprot.readListEnd()
15588 
        else:
15589 
          iprot.skip(ftype)
15590 
      else:
15591 
        iprot.skip(ftype)
15592 
      iprot.readFieldEnd()
15593 
    iprot.readStructEnd()
15594 
 
15595 
  def write(self, oprot):
15596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15598 
      return
15599 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15600 
    if self.itemIds is not None:
15601 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15602 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4757 mandeep.dh 15603 
      for iter276 in self.itemIds:
15604 
        oprot.writeI64(iter276)
4295 varun.gupt 15605 
      oprot.writeListEnd()
15606 
      oprot.writeFieldEnd()
15607 
    oprot.writeFieldStop()
15608 
    oprot.writeStructEnd()
15609 
 
15610 
  def validate(self):
15611 
    return
15612 
 
15613 
 
15614 
  def __repr__(self):
15615 
    L = ['%s=%r' % (key, value)
15616 
      for key, value in self.__dict__.iteritems()]
15617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15618 
 
15619 
  def __eq__(self, other):
15620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15621 
 
15622 
  def __ne__(self, other):
15623 
    return not (self == other)
15624 
 
15625 
class getOrdersForItemIds_result:
15626 
  """
15627 
  Attributes:
15628 
   - success
15629 
  """
15630 
 
15631 
  thrift_spec = (
15632 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15633 
  )
15634 
 
15635 
  def __init__(self, success=None,):
15636 
    self.success = success
15637 
 
15638 
  def read(self, iprot):
15639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15641 
      return
15642 
    iprot.readStructBegin()
15643 
    while True:
15644 
      (fname, ftype, fid) = iprot.readFieldBegin()
15645 
      if ftype == TType.STOP:
15646 
        break
15647 
      if fid == 0:
15648 
        if ftype == TType.LIST:
15649 
          self.success = []
4757 mandeep.dh 15650 
          (_etype280, _size277) = iprot.readListBegin()
15651 
          for _i281 in xrange(_size277):
15652 
            _elem282 = Order()
15653 
            _elem282.read(iprot)
15654 
            self.success.append(_elem282)
4295 varun.gupt 15655 
          iprot.readListEnd()
15656 
        else:
15657 
          iprot.skip(ftype)
15658 
      else:
15659 
        iprot.skip(ftype)
15660 
      iprot.readFieldEnd()
15661 
    iprot.readStructEnd()
15662 
 
15663 
  def write(self, oprot):
15664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15666 
      return
15667 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15668 
    if self.success is not None:
15669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15670 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 15671 
      for iter283 in self.success:
15672 
        iter283.write(oprot)
4295 varun.gupt 15673 
      oprot.writeListEnd()
15674 
      oprot.writeFieldEnd()
15675 
    oprot.writeFieldStop()
15676 
    oprot.writeStructEnd()
15677 
 
15678 
  def validate(self):
15679 
    return
15680 
 
15681 
 
15682 
  def __repr__(self):
15683 
    L = ['%s=%r' % (key, value)
15684 
      for key, value in self.__dict__.iteritems()]
15685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15686 
 
15687 
  def __eq__(self, other):
15688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15689 
 
15690 
  def __ne__(self, other):
15691 
    return not (self == other)
15692 
 
4247 rajveer 15693 
class markOrderCancellationRequestReceived_args:
15694 
  """
15695 
  Attributes:
15696 
   - orderId
15697 
  """
15698 
 
15699 
  thrift_spec = (
15700 
    None, # 0
15701 
    (1, TType.I64, 'orderId', None, None, ), # 1
15702 
  )
15703 
 
15704 
  def __init__(self, orderId=None,):
15705 
    self.orderId = orderId
15706 
 
15707 
  def read(self, iprot):
15708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15710 
      return
15711 
    iprot.readStructBegin()
15712 
    while True:
15713 
      (fname, ftype, fid) = iprot.readFieldBegin()
15714 
      if ftype == TType.STOP:
15715 
        break
15716 
      if fid == 1:
15717 
        if ftype == TType.I64:
15718 
          self.orderId = iprot.readI64();
15719 
        else:
15720 
          iprot.skip(ftype)
15721 
      else:
15722 
        iprot.skip(ftype)
15723 
      iprot.readFieldEnd()
15724 
    iprot.readStructEnd()
15725 
 
15726 
  def write(self, oprot):
15727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15729 
      return
15730 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15731 
    if self.orderId is not None:
15732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15733 
      oprot.writeI64(self.orderId)
15734 
      oprot.writeFieldEnd()
15735 
    oprot.writeFieldStop()
15736 
    oprot.writeStructEnd()
15737 
 
15738 
  def validate(self):
15739 
    return
15740 
 
15741 
 
15742 
  def __repr__(self):
15743 
    L = ['%s=%r' % (key, value)
15744 
      for key, value in self.__dict__.iteritems()]
15745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15746 
 
15747 
  def __eq__(self, other):
15748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15749 
 
15750 
  def __ne__(self, other):
15751 
    return not (self == other)
15752 
 
15753 
class markOrderCancellationRequestReceived_result:
15754 
  """
15755 
  Attributes:
15756 
   - ex
15757 
  """
15758 
 
15759 
  thrift_spec = (
15760 
    None, # 0
15761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15762 
  )
15763 
 
15764 
  def __init__(self, ex=None,):
15765 
    self.ex = ex
15766 
 
15767 
  def read(self, iprot):
15768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15770 
      return
15771 
    iprot.readStructBegin()
15772 
    while True:
15773 
      (fname, ftype, fid) = iprot.readFieldBegin()
15774 
      if ftype == TType.STOP:
15775 
        break
15776 
      if fid == 1:
15777 
        if ftype == TType.STRUCT:
15778 
          self.ex = TransactionServiceException()
15779 
          self.ex.read(iprot)
15780 
        else:
15781 
          iprot.skip(ftype)
15782 
      else:
15783 
        iprot.skip(ftype)
15784 
      iprot.readFieldEnd()
15785 
    iprot.readStructEnd()
15786 
 
15787 
  def write(self, oprot):
15788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15790 
      return
15791 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15792 
    if self.ex is not None:
15793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15794 
      self.ex.write(oprot)
15795 
      oprot.writeFieldEnd()
15796 
    oprot.writeFieldStop()
15797 
    oprot.writeStructEnd()
15798 
 
15799 
  def validate(self):
15800 
    return
15801 
 
15802 
 
15803 
  def __repr__(self):
15804 
    L = ['%s=%r' % (key, value)
15805 
      for key, value in self.__dict__.iteritems()]
15806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15807 
 
15808 
  def __eq__(self, other):
15809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15810 
 
15811 
  def __ne__(self, other):
15812 
    return not (self == other)
15813 
 
15814 
class markOrderCancellationRequestConfirmed_args:
15815 
  """
15816 
  Attributes:
15817 
   - orderId
15818 
  """
15819 
 
15820 
  thrift_spec = (
15821 
    None, # 0
15822 
    (1, TType.I64, 'orderId', None, None, ), # 1
15823 
  )
15824 
 
15825 
  def __init__(self, orderId=None,):
15826 
    self.orderId = orderId
15827 
 
15828 
  def read(self, iprot):
15829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15831 
      return
15832 
    iprot.readStructBegin()
15833 
    while True:
15834 
      (fname, ftype, fid) = iprot.readFieldBegin()
15835 
      if ftype == TType.STOP:
15836 
        break
15837 
      if fid == 1:
15838 
        if ftype == TType.I64:
15839 
          self.orderId = iprot.readI64();
15840 
        else:
15841 
          iprot.skip(ftype)
15842 
      else:
15843 
        iprot.skip(ftype)
15844 
      iprot.readFieldEnd()
15845 
    iprot.readStructEnd()
15846 
 
15847 
  def write(self, oprot):
15848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15850 
      return
15851 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15852 
    if self.orderId is not None:
15853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15854 
      oprot.writeI64(self.orderId)
15855 
      oprot.writeFieldEnd()
15856 
    oprot.writeFieldStop()
15857 
    oprot.writeStructEnd()
15858 
 
15859 
  def validate(self):
15860 
    return
15861 
 
15862 
 
15863 
  def __repr__(self):
15864 
    L = ['%s=%r' % (key, value)
15865 
      for key, value in self.__dict__.iteritems()]
15866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15867 
 
15868 
  def __eq__(self, other):
15869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15870 
 
15871 
  def __ne__(self, other):
15872 
    return not (self == other)
15873 
 
15874 
class markOrderCancellationRequestConfirmed_result:
15875 
  """
15876 
  Attributes:
15877 
   - ex
15878 
  """
15879 
 
15880 
  thrift_spec = (
15881 
    None, # 0
15882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15883 
  )
15884 
 
15885 
  def __init__(self, ex=None,):
15886 
    self.ex = ex
15887 
 
15888 
  def read(self, iprot):
15889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15891 
      return
15892 
    iprot.readStructBegin()
15893 
    while True:
15894 
      (fname, ftype, fid) = iprot.readFieldBegin()
15895 
      if ftype == TType.STOP:
15896 
        break
15897 
      if fid == 1:
15898 
        if ftype == TType.STRUCT:
15899 
          self.ex = TransactionServiceException()
15900 
          self.ex.read(iprot)
15901 
        else:
15902 
          iprot.skip(ftype)
15903 
      else:
15904 
        iprot.skip(ftype)
15905 
      iprot.readFieldEnd()
15906 
    iprot.readStructEnd()
15907 
 
15908 
  def write(self, oprot):
15909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15911 
      return
15912 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15913 
    if self.ex is not None:
15914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15915 
      self.ex.write(oprot)
15916 
      oprot.writeFieldEnd()
15917 
    oprot.writeFieldStop()
15918 
    oprot.writeStructEnd()
15919 
 
15920 
  def validate(self):
15921 
    return
15922 
 
15923 
 
15924 
  def __repr__(self):
15925 
    L = ['%s=%r' % (key, value)
15926 
      for key, value in self.__dict__.iteritems()]
15927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15928 
 
15929 
  def __eq__(self, other):
15930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15931 
 
15932 
  def __ne__(self, other):
15933 
    return not (self == other)
15934 
 
15935 
class markOrderCancellationRequestDenied_args:
15936 
  """
15937 
  Attributes:
15938 
   - orderId
15939 
  """
15940 
 
15941 
  thrift_spec = (
15942 
    None, # 0
15943 
    (1, TType.I64, 'orderId', None, None, ), # 1
15944 
  )
15945 
 
15946 
  def __init__(self, orderId=None,):
15947 
    self.orderId = orderId
15948 
 
15949 
  def read(self, iprot):
15950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15952 
      return
15953 
    iprot.readStructBegin()
15954 
    while True:
15955 
      (fname, ftype, fid) = iprot.readFieldBegin()
15956 
      if ftype == TType.STOP:
15957 
        break
15958 
      if fid == 1:
15959 
        if ftype == TType.I64:
15960 
          self.orderId = iprot.readI64();
15961 
        else:
15962 
          iprot.skip(ftype)
15963 
      else:
15964 
        iprot.skip(ftype)
15965 
      iprot.readFieldEnd()
15966 
    iprot.readStructEnd()
15967 
 
15968 
  def write(self, oprot):
15969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15971 
      return
15972 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15973 
    if self.orderId is not None:
15974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15975 
      oprot.writeI64(self.orderId)
15976 
      oprot.writeFieldEnd()
15977 
    oprot.writeFieldStop()
15978 
    oprot.writeStructEnd()
15979 
 
15980 
  def validate(self):
15981 
    return
15982 
 
15983 
 
15984 
  def __repr__(self):
15985 
    L = ['%s=%r' % (key, value)
15986 
      for key, value in self.__dict__.iteritems()]
15987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15988 
 
15989 
  def __eq__(self, other):
15990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15991 
 
15992 
  def __ne__(self, other):
15993 
    return not (self == other)
15994 
 
15995 
class markOrderCancellationRequestDenied_result:
15996 
  """
15997 
  Attributes:
15998 
   - ex
15999 
  """
16000 
 
16001 
  thrift_spec = (
16002 
    None, # 0
16003 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16004 
  )
16005 
 
16006 
  def __init__(self, ex=None,):
16007 
    self.ex = ex
16008 
 
16009 
  def read(self, iprot):
16010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16012 
      return
16013 
    iprot.readStructBegin()
16014 
    while True:
16015 
      (fname, ftype, fid) = iprot.readFieldBegin()
16016 
      if ftype == TType.STOP:
16017 
        break
16018 
      if fid == 1:
16019 
        if ftype == TType.STRUCT:
16020 
          self.ex = TransactionServiceException()
16021 
          self.ex.read(iprot)
16022 
        else:
16023 
          iprot.skip(ftype)
16024 
      else:
16025 
        iprot.skip(ftype)
16026 
      iprot.readFieldEnd()
16027 
    iprot.readStructEnd()
16028 
 
16029 
  def write(self, oprot):
16030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16032 
      return
16033 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16034 
    if self.ex is not None:
16035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16036 
      self.ex.write(oprot)
16037 
      oprot.writeFieldEnd()
16038 
    oprot.writeFieldStop()
16039 
    oprot.writeStructEnd()
16040 
 
16041 
  def validate(self):
16042 
    return
16043 
 
16044 
 
16045 
  def __repr__(self):
16046 
    L = ['%s=%r' % (key, value)
16047 
      for key, value in self.__dict__.iteritems()]
16048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16049 
 
16050 
  def __eq__(self, other):
16051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16052 
 
16053 
  def __ne__(self, other):
16054 
    return not (self == other)
16055 
 
4258 rajveer 16056 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16057 
  """
16058 
  Attributes:
4258 rajveer 16059 
   - transactionId
4247 rajveer 16060 
  """
16061 
 
16062 
  thrift_spec = (
16063 
    None, # 0
4258 rajveer 16064 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16065 
  )
16066 
 
4258 rajveer 16067 
  def __init__(self, transactionId=None,):
16068 
    self.transactionId = transactionId
4247 rajveer 16069 
 
16070 
  def read(self, iprot):
16071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16073 
      return
16074 
    iprot.readStructBegin()
16075 
    while True:
16076 
      (fname, ftype, fid) = iprot.readFieldBegin()
16077 
      if ftype == TType.STOP:
16078 
        break
16079 
      if fid == 1:
16080 
        if ftype == TType.I64:
4258 rajveer 16081 
          self.transactionId = iprot.readI64();
4247 rajveer 16082 
        else:
16083 
          iprot.skip(ftype)
16084 
      else:
16085 
        iprot.skip(ftype)
16086 
      iprot.readFieldEnd()
16087 
    iprot.readStructEnd()
16088 
 
16089 
  def write(self, oprot):
16090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16092 
      return
4258 rajveer 16093 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16094 
    if self.transactionId is not None:
16095 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16096 
      oprot.writeI64(self.transactionId)
4247 rajveer 16097 
      oprot.writeFieldEnd()
16098 
    oprot.writeFieldStop()
16099 
    oprot.writeStructEnd()
16100 
 
16101 
  def validate(self):
16102 
    return
16103 
 
16104 
 
16105 
  def __repr__(self):
16106 
    L = ['%s=%r' % (key, value)
16107 
      for key, value in self.__dict__.iteritems()]
16108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16109 
 
16110 
  def __eq__(self, other):
16111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16112 
 
16113 
  def __ne__(self, other):
16114 
    return not (self == other)
16115 
 
4258 rajveer 16116 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16117 
  """
16118 
  Attributes:
16119 
   - ex
16120 
  """
16121 
 
16122 
  thrift_spec = (
16123 
    None, # 0
16124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16125 
  )
16126 
 
16127 
  def __init__(self, ex=None,):
16128 
    self.ex = ex
16129 
 
16130 
  def read(self, iprot):
16131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16133 
      return
16134 
    iprot.readStructBegin()
16135 
    while True:
16136 
      (fname, ftype, fid) = iprot.readFieldBegin()
16137 
      if ftype == TType.STOP:
16138 
        break
16139 
      if fid == 1:
16140 
        if ftype == TType.STRUCT:
16141 
          self.ex = TransactionServiceException()
16142 
          self.ex.read(iprot)
16143 
        else:
16144 
          iprot.skip(ftype)
16145 
      else:
16146 
        iprot.skip(ftype)
16147 
      iprot.readFieldEnd()
16148 
    iprot.readStructEnd()
16149 
 
16150 
  def write(self, oprot):
16151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16153 
      return
4258 rajveer 16154 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16155 
    if self.ex is not None:
16156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16157 
      self.ex.write(oprot)
16158 
      oprot.writeFieldEnd()
16159 
    oprot.writeFieldStop()
16160 
    oprot.writeStructEnd()
16161 
 
16162 
  def validate(self):
16163 
    return
16164 
 
16165 
 
16166 
  def __repr__(self):
16167 
    L = ['%s=%r' % (key, value)
16168 
      for key, value in self.__dict__.iteritems()]
16169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16170 
 
16171 
  def __eq__(self, other):
16172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16173 
 
16174 
  def __ne__(self, other):
16175 
    return not (self == other)
4259 anupam.sin 16176 
 
16177 
class refundTransaction_args:
16178 
  """
16179 
  Attributes:
16180 
   - transactionId
16181 
   - refundedBy
16182 
   - reason
16183 
  """
16184 
 
16185 
  thrift_spec = (
16186 
    None, # 0
16187 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16188 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16189 
    (3, TType.STRING, 'reason', None, None, ), # 3
16190 
  )
16191 
 
16192 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16193 
    self.transactionId = transactionId
16194 
    self.refundedBy = refundedBy
16195 
    self.reason = reason
16196 
 
16197 
  def read(self, iprot):
16198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16200 
      return
16201 
    iprot.readStructBegin()
16202 
    while True:
16203 
      (fname, ftype, fid) = iprot.readFieldBegin()
16204 
      if ftype == TType.STOP:
16205 
        break
16206 
      if fid == 1:
16207 
        if ftype == TType.I64:
16208 
          self.transactionId = iprot.readI64();
16209 
        else:
16210 
          iprot.skip(ftype)
16211 
      elif fid == 2:
16212 
        if ftype == TType.STRING:
16213 
          self.refundedBy = iprot.readString();
16214 
        else:
16215 
          iprot.skip(ftype)
16216 
      elif fid == 3:
16217 
        if ftype == TType.STRING:
16218 
          self.reason = iprot.readString();
16219 
        else:
16220 
          iprot.skip(ftype)
16221 
      else:
16222 
        iprot.skip(ftype)
16223 
      iprot.readFieldEnd()
16224 
    iprot.readStructEnd()
16225 
 
16226 
  def write(self, oprot):
16227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16229 
      return
16230 
    oprot.writeStructBegin('refundTransaction_args')
16231 
    if self.transactionId is not None:
16232 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16233 
      oprot.writeI64(self.transactionId)
16234 
      oprot.writeFieldEnd()
16235 
    if self.refundedBy is not None:
16236 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16237 
      oprot.writeString(self.refundedBy)
16238 
      oprot.writeFieldEnd()
16239 
    if self.reason is not None:
16240 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16241 
      oprot.writeString(self.reason)
16242 
      oprot.writeFieldEnd()
16243 
    oprot.writeFieldStop()
16244 
    oprot.writeStructEnd()
16245 
 
16246 
  def validate(self):
16247 
    return
16248 
 
16249 
 
16250 
  def __repr__(self):
16251 
    L = ['%s=%r' % (key, value)
16252 
      for key, value in self.__dict__.iteritems()]
16253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16254 
 
16255 
  def __eq__(self, other):
16256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16257 
 
16258 
  def __ne__(self, other):
16259 
    return not (self == other)
16260 
 
16261 
class refundTransaction_result:
16262 
  """
16263 
  Attributes:
16264 
   - ex
16265 
  """
16266 
 
16267 
  thrift_spec = (
16268 
    None, # 0
16269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16270 
  )
16271 
 
16272 
  def __init__(self, ex=None,):
16273 
    self.ex = ex
16274 
 
16275 
  def read(self, iprot):
16276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16278 
      return
16279 
    iprot.readStructBegin()
16280 
    while True:
16281 
      (fname, ftype, fid) = iprot.readFieldBegin()
16282 
      if ftype == TType.STOP:
16283 
        break
16284 
      if fid == 1:
16285 
        if ftype == TType.STRUCT:
16286 
          self.ex = TransactionServiceException()
16287 
          self.ex.read(iprot)
16288 
        else:
16289 
          iprot.skip(ftype)
16290 
      else:
16291 
        iprot.skip(ftype)
16292 
      iprot.readFieldEnd()
16293 
    iprot.readStructEnd()
16294 
 
16295 
  def write(self, oprot):
16296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16298 
      return
16299 
    oprot.writeStructBegin('refundTransaction_result')
16300 
    if self.ex is not None:
16301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16302 
      self.ex.write(oprot)
16303 
      oprot.writeFieldEnd()
16304 
    oprot.writeFieldStop()
16305 
    oprot.writeStructEnd()
16306 
 
16307 
  def validate(self):
16308 
    return
16309 
 
16310 
 
16311 
  def __repr__(self):
16312 
    L = ['%s=%r' % (key, value)
16313 
      for key, value in self.__dict__.iteritems()]
16314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16315 
 
16316 
  def __eq__(self, other):
16317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16318 
 
16319 
  def __ne__(self, other):
16320 
    return not (self == other)
4285 rajveer 16321 
 
4324 mandeep.dh 16322 
class updateShipmentAddress_args:
16323 
  """
16324 
  Attributes:
16325 
   - orderId
16326 
   - addressId
16327 
  """
16328 
 
16329 
  thrift_spec = (
16330 
    None, # 0
16331 
    (1, TType.I64, 'orderId', None, None, ), # 1
16332 
    (2, TType.I64, 'addressId', None, None, ), # 2
16333 
  )
16334 
 
16335 
  def __init__(self, orderId=None, addressId=None,):
16336 
    self.orderId = orderId
16337 
    self.addressId = addressId
16338 
 
16339 
  def read(self, iprot):
16340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16342 
      return
16343 
    iprot.readStructBegin()
16344 
    while True:
16345 
      (fname, ftype, fid) = iprot.readFieldBegin()
16346 
      if ftype == TType.STOP:
16347 
        break
16348 
      if fid == 1:
16349 
        if ftype == TType.I64:
16350 
          self.orderId = iprot.readI64();
16351 
        else:
16352 
          iprot.skip(ftype)
16353 
      elif fid == 2:
16354 
        if ftype == TType.I64:
16355 
          self.addressId = iprot.readI64();
16356 
        else:
16357 
          iprot.skip(ftype)
16358 
      else:
16359 
        iprot.skip(ftype)
16360 
      iprot.readFieldEnd()
16361 
    iprot.readStructEnd()
16362 
 
16363 
  def write(self, oprot):
16364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16366 
      return
16367 
    oprot.writeStructBegin('updateShipmentAddress_args')
16368 
    if self.orderId is not None:
16369 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16370 
      oprot.writeI64(self.orderId)
16371 
      oprot.writeFieldEnd()
16372 
    if self.addressId is not None:
16373 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16374 
      oprot.writeI64(self.addressId)
16375 
      oprot.writeFieldEnd()
16376 
    oprot.writeFieldStop()
16377 
    oprot.writeStructEnd()
16378 
 
16379 
  def validate(self):
16380 
    return
16381 
 
16382 
 
16383 
  def __repr__(self):
16384 
    L = ['%s=%r' % (key, value)
16385 
      for key, value in self.__dict__.iteritems()]
16386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16387 
 
16388 
  def __eq__(self, other):
16389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16390 
 
16391 
  def __ne__(self, other):
16392 
    return not (self == other)
16393 
 
16394 
class updateShipmentAddress_result:
16395 
  """
16396 
  Attributes:
16397 
   - ex
16398 
  """
16399 
 
16400 
  thrift_spec = (
16401 
    None, # 0
16402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16403 
  )
16404 
 
16405 
  def __init__(self, ex=None,):
16406 
    self.ex = ex
16407 
 
16408 
  def read(self, iprot):
16409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16411 
      return
16412 
    iprot.readStructBegin()
16413 
    while True:
16414 
      (fname, ftype, fid) = iprot.readFieldBegin()
16415 
      if ftype == TType.STOP:
16416 
        break
16417 
      if fid == 1:
16418 
        if ftype == TType.STRUCT:
16419 
          self.ex = TransactionServiceException()
16420 
          self.ex.read(iprot)
16421 
        else:
16422 
          iprot.skip(ftype)
16423 
      else:
16424 
        iprot.skip(ftype)
16425 
      iprot.readFieldEnd()
16426 
    iprot.readStructEnd()
16427 
 
16428 
  def write(self, oprot):
16429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16431 
      return
16432 
    oprot.writeStructBegin('updateShipmentAddress_result')
16433 
    if self.ex is not None:
16434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16435 
      self.ex.write(oprot)
16436 
      oprot.writeFieldEnd()
16437 
    oprot.writeFieldStop()
16438 
    oprot.writeStructEnd()
16439 
 
16440 
  def validate(self):
16441 
    return
16442 
 
16443 
 
16444 
  def __repr__(self):
16445 
    L = ['%s=%r' % (key, value)
16446 
      for key, value in self.__dict__.iteritems()]
16447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16448 
 
16449 
  def __eq__(self, other):
16450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16451 
 
16452 
  def __ne__(self, other):
16453 
    return not (self == other)
16454 
 
4285 rajveer 16455 
class acceptOrdersForItemId_args:
16456 
  """
16457 
  Attributes:
16458 
   - itemId
16459 
   - inventory
16460 
  """
16461 
 
16462 
  thrift_spec = (
16463 
    None, # 0
16464 
    (1, TType.I64, 'itemId', None, None, ), # 1
16465 
    (2, TType.I64, 'inventory', None, None, ), # 2
16466 
  )
16467 
 
16468 
  def __init__(self, itemId=None, inventory=None,):
16469 
    self.itemId = itemId
16470 
    self.inventory = inventory
16471 
 
16472 
  def read(self, iprot):
16473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16475 
      return
16476 
    iprot.readStructBegin()
16477 
    while True:
16478 
      (fname, ftype, fid) = iprot.readFieldBegin()
16479 
      if ftype == TType.STOP:
16480 
        break
16481 
      if fid == 1:
16482 
        if ftype == TType.I64:
16483 
          self.itemId = iprot.readI64();
16484 
        else:
16485 
          iprot.skip(ftype)
16486 
      elif fid == 2:
16487 
        if ftype == TType.I64:
16488 
          self.inventory = iprot.readI64();
16489 
        else:
16490 
          iprot.skip(ftype)
16491 
      else:
16492 
        iprot.skip(ftype)
16493 
      iprot.readFieldEnd()
16494 
    iprot.readStructEnd()
16495 
 
16496 
  def write(self, oprot):
16497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16499 
      return
16500 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16501 
    if self.itemId is not None:
16502 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16503 
      oprot.writeI64(self.itemId)
16504 
      oprot.writeFieldEnd()
16505 
    if self.inventory is not None:
16506 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16507 
      oprot.writeI64(self.inventory)
16508 
      oprot.writeFieldEnd()
16509 
    oprot.writeFieldStop()
16510 
    oprot.writeStructEnd()
16511 
 
16512 
  def validate(self):
16513 
    return
16514 
 
16515 
 
16516 
  def __repr__(self):
16517 
    L = ['%s=%r' % (key, value)
16518 
      for key, value in self.__dict__.iteritems()]
16519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16520 
 
16521 
  def __eq__(self, other):
16522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16523 
 
16524 
  def __ne__(self, other):
16525 
    return not (self == other)
16526 
 
16527 
class acceptOrdersForItemId_result:
16528 
  """
16529 
  Attributes:
16530 
   - success
16531 
   - ex
16532 
  """
16533 
 
16534 
  thrift_spec = (
16535 
    (0, TType.BOOL, 'success', None, None, ), # 0
16536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16537 
  )
16538 
 
16539 
  def __init__(self, success=None, ex=None,):
16540 
    self.success = success
16541 
    self.ex = ex
16542 
 
16543 
  def read(self, iprot):
16544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16546 
      return
16547 
    iprot.readStructBegin()
16548 
    while True:
16549 
      (fname, ftype, fid) = iprot.readFieldBegin()
16550 
      if ftype == TType.STOP:
16551 
        break
16552 
      if fid == 0:
16553 
        if ftype == TType.BOOL:
16554 
          self.success = iprot.readBool();
16555 
        else:
16556 
          iprot.skip(ftype)
16557 
      elif fid == 1:
16558 
        if ftype == TType.STRUCT:
16559 
          self.ex = TransactionServiceException()
16560 
          self.ex.read(iprot)
16561 
        else:
16562 
          iprot.skip(ftype)
16563 
      else:
16564 
        iprot.skip(ftype)
16565 
      iprot.readFieldEnd()
16566 
    iprot.readStructEnd()
16567 
 
16568 
  def write(self, oprot):
16569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16571 
      return
16572 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16573 
    if self.success is not None:
16574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16575 
      oprot.writeBool(self.success)
16576 
      oprot.writeFieldEnd()
16577 
    if self.ex is not None:
16578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16579 
      self.ex.write(oprot)
16580 
      oprot.writeFieldEnd()
16581 
    oprot.writeFieldStop()
16582 
    oprot.writeStructEnd()
16583 
 
16584 
  def validate(self):
16585 
    return
16586 
 
16587 
 
16588 
  def __repr__(self):
16589 
    L = ['%s=%r' % (key, value)
16590 
      for key, value in self.__dict__.iteritems()]
16591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16592 
 
16593 
  def __eq__(self, other):
16594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16595 
 
16596 
  def __ne__(self, other):
16597 
    return not (self == other)
4303 rajveer 16598 
 
16599 
class markOrdersAsPORaised_args:
16600 
  """
16601 
  Attributes:
16602 
   - vendorId
16603 
   - itemId
16604 
   - quantity
16605 
   - estimate
4369 rajveer 16606 
   - isReminder
4303 rajveer 16607 
  """
16608 
 
16609 
  thrift_spec = (
16610 
    None, # 0
16611 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16612 
    (2, TType.I64, 'itemId', None, None, ), # 2
16613 
    (3, TType.I64, 'quantity', None, None, ), # 3
16614 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16615 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16616 
  )
16617 
 
4369 rajveer 16618 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16619 
    self.vendorId = vendorId
16620 
    self.itemId = itemId
16621 
    self.quantity = quantity
16622 
    self.estimate = estimate
4369 rajveer 16623 
    self.isReminder = isReminder
4303 rajveer 16624 
 
16625 
  def read(self, iprot):
16626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16628 
      return
16629 
    iprot.readStructBegin()
16630 
    while True:
16631 
      (fname, ftype, fid) = iprot.readFieldBegin()
16632 
      if ftype == TType.STOP:
16633 
        break
16634 
      if fid == 1:
16635 
        if ftype == TType.I64:
16636 
          self.vendorId = iprot.readI64();
16637 
        else:
16638 
          iprot.skip(ftype)
16639 
      elif fid == 2:
16640 
        if ftype == TType.I64:
16641 
          self.itemId = iprot.readI64();
16642 
        else:
16643 
          iprot.skip(ftype)
16644 
      elif fid == 3:
16645 
        if ftype == TType.I64:
16646 
          self.quantity = iprot.readI64();
16647 
        else:
16648 
          iprot.skip(ftype)
16649 
      elif fid == 4:
16650 
        if ftype == TType.I64:
16651 
          self.estimate = iprot.readI64();
16652 
        else:
16653 
          iprot.skip(ftype)
4369 rajveer 16654 
      elif fid == 5:
16655 
        if ftype == TType.BOOL:
16656 
          self.isReminder = iprot.readBool();
16657 
        else:
16658 
          iprot.skip(ftype)
4303 rajveer 16659 
      else:
16660 
        iprot.skip(ftype)
16661 
      iprot.readFieldEnd()
16662 
    iprot.readStructEnd()
16663 
 
16664 
  def write(self, oprot):
16665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16667 
      return
16668 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16669 
    if self.vendorId is not None:
16670 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16671 
      oprot.writeI64(self.vendorId)
16672 
      oprot.writeFieldEnd()
16673 
    if self.itemId is not None:
16674 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16675 
      oprot.writeI64(self.itemId)
16676 
      oprot.writeFieldEnd()
16677 
    if self.quantity is not None:
16678 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16679 
      oprot.writeI64(self.quantity)
16680 
      oprot.writeFieldEnd()
16681 
    if self.estimate is not None:
16682 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16683 
      oprot.writeI64(self.estimate)
16684 
      oprot.writeFieldEnd()
4369 rajveer 16685 
    if self.isReminder is not None:
16686 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16687 
      oprot.writeBool(self.isReminder)
16688 
      oprot.writeFieldEnd()
4303 rajveer 16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
16706 
 
16707 
class markOrdersAsPORaised_result:
16708 
  """
16709 
  Attributes:
16710 
   - ex
16711 
  """
16712 
 
16713 
  thrift_spec = (
16714 
    None, # 0
16715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16716 
  )
16717 
 
16718 
  def __init__(self, ex=None,):
16719 
    self.ex = ex
16720 
 
16721 
  def read(self, iprot):
16722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16724 
      return
16725 
    iprot.readStructBegin()
16726 
    while True:
16727 
      (fname, ftype, fid) = iprot.readFieldBegin()
16728 
      if ftype == TType.STOP:
16729 
        break
16730 
      if fid == 1:
16731 
        if ftype == TType.STRUCT:
16732 
          self.ex = TransactionServiceException()
16733 
          self.ex.read(iprot)
16734 
        else:
16735 
          iprot.skip(ftype)
16736 
      else:
16737 
        iprot.skip(ftype)
16738 
      iprot.readFieldEnd()
16739 
    iprot.readStructEnd()
16740 
 
16741 
  def write(self, oprot):
16742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16744 
      return
16745 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16746 
    if self.ex is not None:
16747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16748 
      self.ex.write(oprot)
16749 
      oprot.writeFieldEnd()
16750 
    oprot.writeFieldStop()
16751 
    oprot.writeStructEnd()
16752 
 
16753 
  def validate(self):
16754 
    return
16755 
 
16756 
 
16757 
  def __repr__(self):
16758 
    L = ['%s=%r' % (key, value)
16759 
      for key, value in self.__dict__.iteritems()]
16760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16761 
 
16762 
  def __eq__(self, other):
16763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16764 
 
16765 
  def __ne__(self, other):
16766 
    return not (self == other)
16767 
 
16768 
class markOrdersAsReversalInitiated_args:
16769 
  """
16770 
  Attributes:
16771 
   - vendorId
16772 
   - itemId
16773 
   - quantity
16774 
   - estimate
4369 rajveer 16775 
   - isReminder
4303 rajveer 16776 
  """
16777 
 
16778 
  thrift_spec = (
16779 
    None, # 0
16780 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16781 
    (2, TType.I64, 'itemId', None, None, ), # 2
16782 
    (3, TType.I64, 'quantity', None, None, ), # 3
16783 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16784 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16785 
  )
16786 
 
4369 rajveer 16787 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16788 
    self.vendorId = vendorId
16789 
    self.itemId = itemId
16790 
    self.quantity = quantity
16791 
    self.estimate = estimate
4369 rajveer 16792 
    self.isReminder = isReminder
4303 rajveer 16793 
 
16794 
  def read(self, iprot):
16795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16797 
      return
16798 
    iprot.readStructBegin()
16799 
    while True:
16800 
      (fname, ftype, fid) = iprot.readFieldBegin()
16801 
      if ftype == TType.STOP:
16802 
        break
16803 
      if fid == 1:
16804 
        if ftype == TType.I64:
16805 
          self.vendorId = iprot.readI64();
16806 
        else:
16807 
          iprot.skip(ftype)
16808 
      elif fid == 2:
16809 
        if ftype == TType.I64:
16810 
          self.itemId = iprot.readI64();
16811 
        else:
16812 
          iprot.skip(ftype)
16813 
      elif fid == 3:
16814 
        if ftype == TType.I64:
16815 
          self.quantity = iprot.readI64();
16816 
        else:
16817 
          iprot.skip(ftype)
16818 
      elif fid == 4:
16819 
        if ftype == TType.I64:
16820 
          self.estimate = iprot.readI64();
16821 
        else:
16822 
          iprot.skip(ftype)
4369 rajveer 16823 
      elif fid == 5:
16824 
        if ftype == TType.BOOL:
16825 
          self.isReminder = iprot.readBool();
16826 
        else:
16827 
          iprot.skip(ftype)
4303 rajveer 16828 
      else:
16829 
        iprot.skip(ftype)
16830 
      iprot.readFieldEnd()
16831 
    iprot.readStructEnd()
16832 
 
16833 
  def write(self, oprot):
16834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16836 
      return
16837 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16838 
    if self.vendorId is not None:
16839 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16840 
      oprot.writeI64(self.vendorId)
16841 
      oprot.writeFieldEnd()
16842 
    if self.itemId is not None:
16843 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16844 
      oprot.writeI64(self.itemId)
16845 
      oprot.writeFieldEnd()
16846 
    if self.quantity is not None:
16847 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16848 
      oprot.writeI64(self.quantity)
16849 
      oprot.writeFieldEnd()
16850 
    if self.estimate is not None:
16851 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16852 
      oprot.writeI64(self.estimate)
16853 
      oprot.writeFieldEnd()
4369 rajveer 16854 
    if self.isReminder is not None:
16855 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16856 
      oprot.writeBool(self.isReminder)
16857 
      oprot.writeFieldEnd()
4303 rajveer 16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
16876 
class markOrdersAsReversalInitiated_result:
16877 
  """
16878 
  Attributes:
16879 
   - ex
16880 
  """
16881 
 
16882 
  thrift_spec = (
16883 
    None, # 0
16884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16885 
  )
16886 
 
16887 
  def __init__(self, ex=None,):
16888 
    self.ex = ex
16889 
 
16890 
  def read(self, iprot):
16891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16893 
      return
16894 
    iprot.readStructBegin()
16895 
    while True:
16896 
      (fname, ftype, fid) = iprot.readFieldBegin()
16897 
      if ftype == TType.STOP:
16898 
        break
16899 
      if fid == 1:
16900 
        if ftype == TType.STRUCT:
16901 
          self.ex = TransactionServiceException()
16902 
          self.ex.read(iprot)
16903 
        else:
16904 
          iprot.skip(ftype)
16905 
      else:
16906 
        iprot.skip(ftype)
16907 
      iprot.readFieldEnd()
16908 
    iprot.readStructEnd()
16909 
 
16910 
  def write(self, oprot):
16911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16913 
      return
16914 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16915 
    if self.ex is not None:
16916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16917 
      self.ex.write(oprot)
16918 
      oprot.writeFieldEnd()
16919 
    oprot.writeFieldStop()
16920 
    oprot.writeStructEnd()
16921 
 
16922 
  def validate(self):
16923 
    return
16924 
 
16925 
 
16926 
  def __repr__(self):
16927 
    L = ['%s=%r' % (key, value)
16928 
      for key, value in self.__dict__.iteritems()]
16929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16930 
 
16931 
  def __eq__(self, other):
16932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16933 
 
16934 
  def __ne__(self, other):
16935 
    return not (self == other)
16936 
 
16937 
class markOrdersAsNotAvailabke_args:
16938 
  """
16939 
  Attributes:
16940 
   - vendorId
16941 
   - itemId
16942 
   - quantity
16943 
   - estimate
4369 rajveer 16944 
   - isReminder
4303 rajveer 16945 
  """
16946 
 
16947 
  thrift_spec = (
16948 
    None, # 0
16949 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16950 
    (2, TType.I64, 'itemId', None, None, ), # 2
16951 
    (3, TType.I64, 'quantity', None, None, ), # 3
16952 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16953 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16954 
  )
16955 
 
4369 rajveer 16956 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16957 
    self.vendorId = vendorId
16958 
    self.itemId = itemId
16959 
    self.quantity = quantity
16960 
    self.estimate = estimate
4369 rajveer 16961 
    self.isReminder = isReminder
4303 rajveer 16962 
 
16963 
  def read(self, iprot):
16964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16966 
      return
16967 
    iprot.readStructBegin()
16968 
    while True:
16969 
      (fname, ftype, fid) = iprot.readFieldBegin()
16970 
      if ftype == TType.STOP:
16971 
        break
16972 
      if fid == 1:
16973 
        if ftype == TType.I64:
16974 
          self.vendorId = iprot.readI64();
16975 
        else:
16976 
          iprot.skip(ftype)
16977 
      elif fid == 2:
16978 
        if ftype == TType.I64:
16979 
          self.itemId = iprot.readI64();
16980 
        else:
16981 
          iprot.skip(ftype)
16982 
      elif fid == 3:
16983 
        if ftype == TType.I64:
16984 
          self.quantity = iprot.readI64();
16985 
        else:
16986 
          iprot.skip(ftype)
16987 
      elif fid == 4:
16988 
        if ftype == TType.I64:
16989 
          self.estimate = iprot.readI64();
16990 
        else:
16991 
          iprot.skip(ftype)
4369 rajveer 16992 
      elif fid == 5:
16993 
        if ftype == TType.BOOL:
16994 
          self.isReminder = iprot.readBool();
16995 
        else:
16996 
          iprot.skip(ftype)
4303 rajveer 16997 
      else:
16998 
        iprot.skip(ftype)
16999 
      iprot.readFieldEnd()
17000 
    iprot.readStructEnd()
17001 
 
17002 
  def write(self, oprot):
17003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17005 
      return
17006 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17007 
    if self.vendorId is not None:
17008 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17009 
      oprot.writeI64(self.vendorId)
17010 
      oprot.writeFieldEnd()
17011 
    if self.itemId is not None:
17012 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17013 
      oprot.writeI64(self.itemId)
17014 
      oprot.writeFieldEnd()
17015 
    if self.quantity is not None:
17016 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17017 
      oprot.writeI64(self.quantity)
17018 
      oprot.writeFieldEnd()
17019 
    if self.estimate is not None:
17020 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17021 
      oprot.writeI64(self.estimate)
17022 
      oprot.writeFieldEnd()
4369 rajveer 17023 
    if self.isReminder is not None:
17024 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17025 
      oprot.writeBool(self.isReminder)
17026 
      oprot.writeFieldEnd()
4303 rajveer 17027 
    oprot.writeFieldStop()
17028 
    oprot.writeStructEnd()
17029 
 
17030 
  def validate(self):
17031 
    return
17032 
 
17033 
 
17034 
  def __repr__(self):
17035 
    L = ['%s=%r' % (key, value)
17036 
      for key, value in self.__dict__.iteritems()]
17037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17038 
 
17039 
  def __eq__(self, other):
17040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17041 
 
17042 
  def __ne__(self, other):
17043 
    return not (self == other)
17044 
 
17045 
class markOrdersAsNotAvailabke_result:
17046 
  """
17047 
  Attributes:
17048 
   - ex
17049 
  """
17050 
 
17051 
  thrift_spec = (
17052 
    None, # 0
17053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17054 
  )
17055 
 
17056 
  def __init__(self, ex=None,):
17057 
    self.ex = ex
17058 
 
17059 
  def read(self, iprot):
17060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17062 
      return
17063 
    iprot.readStructBegin()
17064 
    while True:
17065 
      (fname, ftype, fid) = iprot.readFieldBegin()
17066 
      if ftype == TType.STOP:
17067 
        break
17068 
      if fid == 1:
17069 
        if ftype == TType.STRUCT:
17070 
          self.ex = TransactionServiceException()
17071 
          self.ex.read(iprot)
17072 
        else:
17073 
          iprot.skip(ftype)
17074 
      else:
17075 
        iprot.skip(ftype)
17076 
      iprot.readFieldEnd()
17077 
    iprot.readStructEnd()
17078 
 
17079 
  def write(self, oprot):
17080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17082 
      return
17083 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17084 
    if self.ex is not None:
17085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17086 
      self.ex.write(oprot)
17087 
      oprot.writeFieldEnd()
17088 
    oprot.writeFieldStop()
17089 
    oprot.writeStructEnd()
17090 
 
17091 
  def validate(self):
17092 
    return
17093 
 
17094 
 
17095 
  def __repr__(self):
17096 
    L = ['%s=%r' % (key, value)
17097 
      for key, value in self.__dict__.iteritems()]
17098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17099 
 
17100 
  def __eq__(self, other):
17101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17102 
 
17103 
  def __ne__(self, other):
17104 
    return not (self == other)
4369 rajveer 17105 
 
17106 
class markOrdersAsTimeout_args:
17107 
  """
17108 
  Attributes:
17109 
   - vendorId
17110 
  """
17111 
 
17112 
  thrift_spec = (
17113 
    None, # 0
17114 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17115 
  )
17116 
 
17117 
  def __init__(self, vendorId=None,):
17118 
    self.vendorId = vendorId
17119 
 
17120 
  def read(self, iprot):
17121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17123 
      return
17124 
    iprot.readStructBegin()
17125 
    while True:
17126 
      (fname, ftype, fid) = iprot.readFieldBegin()
17127 
      if ftype == TType.STOP:
17128 
        break
17129 
      if fid == 1:
17130 
        if ftype == TType.I64:
17131 
          self.vendorId = iprot.readI64();
17132 
        else:
17133 
          iprot.skip(ftype)
17134 
      else:
17135 
        iprot.skip(ftype)
17136 
      iprot.readFieldEnd()
17137 
    iprot.readStructEnd()
17138 
 
17139 
  def write(self, oprot):
17140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17142 
      return
17143 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17144 
    if self.vendorId is not None:
17145 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17146 
      oprot.writeI64(self.vendorId)
17147 
      oprot.writeFieldEnd()
17148 
    oprot.writeFieldStop()
17149 
    oprot.writeStructEnd()
17150 
 
17151 
  def validate(self):
17152 
    return
17153 
 
17154 
 
17155 
  def __repr__(self):
17156 
    L = ['%s=%r' % (key, value)
17157 
      for key, value in self.__dict__.iteritems()]
17158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17159 
 
17160 
  def __eq__(self, other):
17161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17162 
 
17163 
  def __ne__(self, other):
17164 
    return not (self == other)
17165 
 
17166 
class markOrdersAsTimeout_result:
17167 
  """
17168 
  Attributes:
17169 
   - success
17170 
   - ex
17171 
  """
17172 
 
17173 
  thrift_spec = (
17174 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17175 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17176 
  )
17177 
 
17178 
  def __init__(self, success=None, ex=None,):
17179 
    self.success = success
17180 
    self.ex = ex
17181 
 
17182 
  def read(self, iprot):
17183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17185 
      return
17186 
    iprot.readStructBegin()
17187 
    while True:
17188 
      (fname, ftype, fid) = iprot.readFieldBegin()
17189 
      if ftype == TType.STOP:
17190 
        break
17191 
      if fid == 0:
17192 
        if ftype == TType.MAP:
17193 
          self.success = {}
4757 mandeep.dh 17194 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
17195 
          for _i288 in xrange(_size284):
17196 
            _key289 = iprot.readI32();
17197 
            _val290 = TimeoutSummary()
17198 
            _val290.read(iprot)
17199 
            self.success[_key289] = _val290
4369 rajveer 17200 
          iprot.readMapEnd()
17201 
        else:
17202 
          iprot.skip(ftype)
17203 
      elif fid == 1:
17204 
        if ftype == TType.STRUCT:
17205 
          self.ex = TransactionServiceException()
17206 
          self.ex.read(iprot)
17207 
        else:
17208 
          iprot.skip(ftype)
17209 
      else:
17210 
        iprot.skip(ftype)
17211 
      iprot.readFieldEnd()
17212 
    iprot.readStructEnd()
17213 
 
17214 
  def write(self, oprot):
17215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17217 
      return
17218 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17219 
    if self.success is not None:
17220 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17221 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4757 mandeep.dh 17222 
      for kiter291,viter292 in self.success.items():
17223 
        oprot.writeI32(kiter291)
17224 
        viter292.write(oprot)
4369 rajveer 17225 
      oprot.writeMapEnd()
17226 
      oprot.writeFieldEnd()
17227 
    if self.ex is not None:
17228 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17229 
      self.ex.write(oprot)
17230 
      oprot.writeFieldEnd()
17231 
    oprot.writeFieldStop()
17232 
    oprot.writeStructEnd()
17233 
 
17234 
  def validate(self):
17235 
    return
17236 
 
17237 
 
17238 
  def __repr__(self):
17239 
    L = ['%s=%r' % (key, value)
17240 
      for key, value in self.__dict__.iteritems()]
17241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17242 
 
17243 
  def __eq__(self, other):
17244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17245 
 
17246 
  def __ne__(self, other):
17247 
    return not (self == other)
4386 anupam.sin 17248 
 
4662 rajveer 17249 
class markOrderAsLostInTransit_args:
17250 
  """
17251 
  Attributes:
17252 
   - orderId
17253 
  """
17254 
 
17255 
  thrift_spec = (
17256 
    None, # 0
17257 
    (1, TType.I64, 'orderId', None, None, ), # 1
17258 
  )
17259 
 
17260 
  def __init__(self, orderId=None,):
17261 
    self.orderId = orderId
17262 
 
17263 
  def read(self, iprot):
17264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17266 
      return
17267 
    iprot.readStructBegin()
17268 
    while True:
17269 
      (fname, ftype, fid) = iprot.readFieldBegin()
17270 
      if ftype == TType.STOP:
17271 
        break
17272 
      if fid == 1:
17273 
        if ftype == TType.I64:
17274 
          self.orderId = iprot.readI64();
17275 
        else:
17276 
          iprot.skip(ftype)
17277 
      else:
17278 
        iprot.skip(ftype)
17279 
      iprot.readFieldEnd()
17280 
    iprot.readStructEnd()
17281 
 
17282 
  def write(self, oprot):
17283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17285 
      return
17286 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17287 
    if self.orderId is not None:
17288 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17289 
      oprot.writeI64(self.orderId)
17290 
      oprot.writeFieldEnd()
17291 
    oprot.writeFieldStop()
17292 
    oprot.writeStructEnd()
17293 
 
17294 
  def validate(self):
17295 
    return
17296 
 
17297 
 
17298 
  def __repr__(self):
17299 
    L = ['%s=%r' % (key, value)
17300 
      for key, value in self.__dict__.iteritems()]
17301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17302 
 
17303 
  def __eq__(self, other):
17304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17305 
 
17306 
  def __ne__(self, other):
17307 
    return not (self == other)
17308 
 
17309 
class markOrderAsLostInTransit_result:
17310 
  """
17311 
  Attributes:
17312 
   - success
17313 
   - ex
17314 
  """
17315 
 
17316 
  thrift_spec = (
17317 
    (0, TType.BOOL, 'success', None, None, ), # 0
17318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17319 
  )
17320 
 
17321 
  def __init__(self, success=None, ex=None,):
17322 
    self.success = success
17323 
    self.ex = ex
17324 
 
17325 
  def read(self, iprot):
17326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17328 
      return
17329 
    iprot.readStructBegin()
17330 
    while True:
17331 
      (fname, ftype, fid) = iprot.readFieldBegin()
17332 
      if ftype == TType.STOP:
17333 
        break
17334 
      if fid == 0:
17335 
        if ftype == TType.BOOL:
17336 
          self.success = iprot.readBool();
17337 
        else:
17338 
          iprot.skip(ftype)
17339 
      elif fid == 1:
17340 
        if ftype == TType.STRUCT:
17341 
          self.ex = TransactionServiceException()
17342 
          self.ex.read(iprot)
17343 
        else:
17344 
          iprot.skip(ftype)
17345 
      else:
17346 
        iprot.skip(ftype)
17347 
      iprot.readFieldEnd()
17348 
    iprot.readStructEnd()
17349 
 
17350 
  def write(self, oprot):
17351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17353 
      return
17354 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17355 
    if self.success is not None:
17356 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17357 
      oprot.writeBool(self.success)
17358 
      oprot.writeFieldEnd()
17359 
    if self.ex is not None:
17360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17361 
      self.ex.write(oprot)
17362 
      oprot.writeFieldEnd()
17363 
    oprot.writeFieldStop()
17364 
    oprot.writeStructEnd()
17365 
 
17366 
  def validate(self):
17367 
    return
17368 
 
17369 
 
17370 
  def __repr__(self):
17371 
    L = ['%s=%r' % (key, value)
17372 
      for key, value in self.__dict__.iteritems()]
17373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17374 
 
17375 
  def __eq__(self, other):
17376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17377 
 
17378 
  def __ne__(self, other):
17379 
    return not (self == other)
17380 
 
4386 anupam.sin 17381 
class getOrderForAwb_args:
17382 
  """
17383 
  Attributes:
17384 
   - awb
17385 
  """
17386 
 
17387 
  thrift_spec = (
17388 
    None, # 0
17389 
    (1, TType.STRING, 'awb', None, None, ), # 1
17390 
  )
17391 
 
17392 
  def __init__(self, awb=None,):
17393 
    self.awb = awb
17394 
 
17395 
  def read(self, iprot):
17396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17398 
      return
17399 
    iprot.readStructBegin()
17400 
    while True:
17401 
      (fname, ftype, fid) = iprot.readFieldBegin()
17402 
      if ftype == TType.STOP:
17403 
        break
17404 
      if fid == 1:
17405 
        if ftype == TType.STRING:
17406 
          self.awb = iprot.readString();
17407 
        else:
17408 
          iprot.skip(ftype)
17409 
      else:
17410 
        iprot.skip(ftype)
17411 
      iprot.readFieldEnd()
17412 
    iprot.readStructEnd()
17413 
 
17414 
  def write(self, oprot):
17415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17417 
      return
17418 
    oprot.writeStructBegin('getOrderForAwb_args')
17419 
    if self.awb is not None:
17420 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17421 
      oprot.writeString(self.awb)
17422 
      oprot.writeFieldEnd()
17423 
    oprot.writeFieldStop()
17424 
    oprot.writeStructEnd()
17425 
 
17426 
  def validate(self):
17427 
    return
17428 
 
17429 
 
17430 
  def __repr__(self):
17431 
    L = ['%s=%r' % (key, value)
17432 
      for key, value in self.__dict__.iteritems()]
17433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17434 
 
17435 
  def __eq__(self, other):
17436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17437 
 
17438 
  def __ne__(self, other):
17439 
    return not (self == other)
17440 
 
17441 
class getOrderForAwb_result:
17442 
  """
17443 
  Attributes:
17444 
   - success
17445 
   - ex
17446 
  """
17447 
 
17448 
  thrift_spec = (
17449 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17450 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17451 
  )
17452 
 
17453 
  def __init__(self, success=None, ex=None,):
17454 
    self.success = success
17455 
    self.ex = ex
17456 
 
17457 
  def read(self, iprot):
17458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17460 
      return
17461 
    iprot.readStructBegin()
17462 
    while True:
17463 
      (fname, ftype, fid) = iprot.readFieldBegin()
17464 
      if ftype == TType.STOP:
17465 
        break
17466 
      if fid == 0:
17467 
        if ftype == TType.STRUCT:
17468 
          self.success = Order()
17469 
          self.success.read(iprot)
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 1:
17473 
        if ftype == TType.STRUCT:
17474 
          self.ex = TransactionServiceException()
17475 
          self.ex.read(iprot)
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      else:
17479 
        iprot.skip(ftype)
17480 
      iprot.readFieldEnd()
17481 
    iprot.readStructEnd()
17482 
 
17483 
  def write(self, oprot):
17484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17486 
      return
17487 
    oprot.writeStructBegin('getOrderForAwb_result')
17488 
    if self.success is not None:
17489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17490 
      self.success.write(oprot)
17491 
      oprot.writeFieldEnd()
17492 
    if self.ex is not None:
17493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17494 
      self.ex.write(oprot)
17495 
      oprot.writeFieldEnd()
17496 
    oprot.writeFieldStop()
17497 
    oprot.writeStructEnd()
17498 
 
17499 
  def validate(self):
17500 
    return
17501 
 
17502 
 
17503 
  def __repr__(self):
17504 
    L = ['%s=%r' % (key, value)
17505 
      for key, value in self.__dict__.iteritems()]
17506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17507 
 
17508 
  def __eq__(self, other):
17509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17510 
 
17511 
  def __ne__(self, other):
17512 
    return not (self == other)
4506 phani.kuma 17513 
 
17514 
class getOrdersForProviderForStatus_args:
17515 
  """
17516 
  Attributes:
17517 
   - logistics_provider_id
17518 
   - order_status
17519 
  """
17520 
 
17521 
  thrift_spec = (
17522 
    None, # 0
17523 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17524 
    (2, TType.I32, 'order_status', None, None, ), # 2
17525 
  )
17526 
 
17527 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17528 
    self.logistics_provider_id = logistics_provider_id
17529 
    self.order_status = order_status
17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      if fid == 1:
17541 
        if ftype == TType.I64:
17542 
          self.logistics_provider_id = iprot.readI64();
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      elif fid == 2:
17546 
        if ftype == TType.I32:
17547 
          self.order_status = iprot.readI32();
17548 
        else:
17549 
          iprot.skip(ftype)
17550 
      else:
17551 
        iprot.skip(ftype)
17552 
      iprot.readFieldEnd()
17553 
    iprot.readStructEnd()
17554 
 
17555 
  def write(self, oprot):
17556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17558 
      return
17559 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17560 
    if self.logistics_provider_id is not None:
17561 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17562 
      oprot.writeI64(self.logistics_provider_id)
17563 
      oprot.writeFieldEnd()
17564 
    if self.order_status is not None:
17565 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17566 
      oprot.writeI32(self.order_status)
17567 
      oprot.writeFieldEnd()
17568 
    oprot.writeFieldStop()
17569 
    oprot.writeStructEnd()
17570 
 
17571 
  def validate(self):
17572 
    return
17573 
 
17574 
 
17575 
  def __repr__(self):
17576 
    L = ['%s=%r' % (key, value)
17577 
      for key, value in self.__dict__.iteritems()]
17578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17579 
 
17580 
  def __eq__(self, other):
17581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17582 
 
17583 
  def __ne__(self, other):
17584 
    return not (self == other)
17585 
 
17586 
class getOrdersForProviderForStatus_result:
17587 
  """
17588 
  Attributes:
17589 
   - success
17590 
   - ex
17591 
  """
17592 
 
17593 
  thrift_spec = (
17594 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17596 
  )
17597 
 
17598 
  def __init__(self, success=None, ex=None,):
17599 
    self.success = success
17600 
    self.ex = ex
17601 
 
17602 
  def read(self, iprot):
17603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17605 
      return
17606 
    iprot.readStructBegin()
17607 
    while True:
17608 
      (fname, ftype, fid) = iprot.readFieldBegin()
17609 
      if ftype == TType.STOP:
17610 
        break
17611 
      if fid == 0:
17612 
        if ftype == TType.LIST:
17613 
          self.success = []
4757 mandeep.dh 17614 
          (_etype296, _size293) = iprot.readListBegin()
17615 
          for _i297 in xrange(_size293):
17616 
            _elem298 = Order()
17617 
            _elem298.read(iprot)
17618 
            self.success.append(_elem298)
4506 phani.kuma 17619 
          iprot.readListEnd()
17620 
        else:
17621 
          iprot.skip(ftype)
17622 
      elif fid == 1:
17623 
        if ftype == TType.STRUCT:
17624 
          self.ex = TransactionServiceException()
17625 
          self.ex.read(iprot)
17626 
        else:
17627 
          iprot.skip(ftype)
17628 
      else:
17629 
        iprot.skip(ftype)
17630 
      iprot.readFieldEnd()
17631 
    iprot.readStructEnd()
17632 
 
17633 
  def write(self, oprot):
17634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17636 
      return
17637 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17638 
    if self.success is not None:
17639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17641 
      for iter299 in self.success:
17642 
        iter299.write(oprot)
4506 phani.kuma 17643 
      oprot.writeListEnd()
17644 
      oprot.writeFieldEnd()
17645 
    if self.ex is not None:
17646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17647 
      self.ex.write(oprot)
17648 
      oprot.writeFieldEnd()
17649 
    oprot.writeFieldStop()
17650 
    oprot.writeStructEnd()
17651 
 
17652 
  def validate(self):
17653 
    return
17654 
 
17655 
 
17656 
  def __repr__(self):
17657 
    L = ['%s=%r' % (key, value)
17658 
      for key, value in self.__dict__.iteritems()]
17659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17660 
 
17661 
  def __eq__(self, other):
17662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17663 
 
17664 
  def __ne__(self, other):
17665 
    return not (self == other)
4600 varun.gupt 17666 
 
17667 
class getBilledOrdersForVendor_args:
17668 
  """
17669 
  Attributes:
17670 
   - vendorId
17671 
   - billingDateFrom
17672 
   - billingDateTo
17673 
  """
17674 
 
17675 
  thrift_spec = (
17676 
    None, # 0
17677 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17678 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17679 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17680 
  )
17681 
 
17682 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17683 
    self.vendorId = vendorId
17684 
    self.billingDateFrom = billingDateFrom
17685 
    self.billingDateTo = billingDateTo
17686 
 
17687 
  def read(self, iprot):
17688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17690 
      return
17691 
    iprot.readStructBegin()
17692 
    while True:
17693 
      (fname, ftype, fid) = iprot.readFieldBegin()
17694 
      if ftype == TType.STOP:
17695 
        break
17696 
      if fid == 1:
17697 
        if ftype == TType.I64:
17698 
          self.vendorId = iprot.readI64();
17699 
        else:
17700 
          iprot.skip(ftype)
17701 
      elif fid == 2:
17702 
        if ftype == TType.I64:
17703 
          self.billingDateFrom = iprot.readI64();
17704 
        else:
17705 
          iprot.skip(ftype)
17706 
      elif fid == 3:
17707 
        if ftype == TType.I64:
17708 
          self.billingDateTo = iprot.readI64();
17709 
        else:
17710 
          iprot.skip(ftype)
17711 
      else:
17712 
        iprot.skip(ftype)
17713 
      iprot.readFieldEnd()
17714 
    iprot.readStructEnd()
17715 
 
17716 
  def write(self, oprot):
17717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17719 
      return
17720 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17721 
    if self.vendorId is not None:
17722 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17723 
      oprot.writeI64(self.vendorId)
17724 
      oprot.writeFieldEnd()
17725 
    if self.billingDateFrom is not None:
17726 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17727 
      oprot.writeI64(self.billingDateFrom)
17728 
      oprot.writeFieldEnd()
17729 
    if self.billingDateTo is not None:
17730 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17731 
      oprot.writeI64(self.billingDateTo)
17732 
      oprot.writeFieldEnd()
17733 
    oprot.writeFieldStop()
17734 
    oprot.writeStructEnd()
17735 
 
17736 
  def validate(self):
17737 
    return
17738 
 
17739 
 
17740 
  def __repr__(self):
17741 
    L = ['%s=%r' % (key, value)
17742 
      for key, value in self.__dict__.iteritems()]
17743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17744 
 
17745 
  def __eq__(self, other):
17746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17747 
 
17748 
  def __ne__(self, other):
17749 
    return not (self == other)
17750 
 
17751 
class getBilledOrdersForVendor_result:
17752 
  """
17753 
  Attributes:
17754 
   - success
17755 
   - ex
17756 
  """
17757 
 
17758 
  thrift_spec = (
17759 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17761 
  )
17762 
 
17763 
  def __init__(self, success=None, ex=None,):
17764 
    self.success = success
17765 
    self.ex = ex
17766 
 
17767 
  def read(self, iprot):
17768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17770 
      return
17771 
    iprot.readStructBegin()
17772 
    while True:
17773 
      (fname, ftype, fid) = iprot.readFieldBegin()
17774 
      if ftype == TType.STOP:
17775 
        break
17776 
      if fid == 0:
17777 
        if ftype == TType.LIST:
17778 
          self.success = []
4757 mandeep.dh 17779 
          (_etype303, _size300) = iprot.readListBegin()
17780 
          for _i304 in xrange(_size300):
17781 
            _elem305 = Order()
17782 
            _elem305.read(iprot)
17783 
            self.success.append(_elem305)
4600 varun.gupt 17784 
          iprot.readListEnd()
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      elif fid == 1:
17788 
        if ftype == TType.STRUCT:
17789 
          self.ex = TransactionServiceException()
17790 
          self.ex.read(iprot)
17791 
        else:
17792 
          iprot.skip(ftype)
17793 
      else:
17794 
        iprot.skip(ftype)
17795 
      iprot.readFieldEnd()
17796 
    iprot.readStructEnd()
17797 
 
17798 
  def write(self, oprot):
17799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17801 
      return
17802 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17803 
    if self.success is not None:
17804 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17805 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17806 
      for iter306 in self.success:
17807 
        iter306.write(oprot)
4600 varun.gupt 17808 
      oprot.writeListEnd()
17809 
      oprot.writeFieldEnd()
17810 
    if self.ex is not None:
17811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17812 
      self.ex.write(oprot)
17813 
      oprot.writeFieldEnd()
17814 
    oprot.writeFieldStop()
17815 
    oprot.writeStructEnd()
17816 
 
17817 
  def validate(self):
17818 
    return
17819 
 
17820 
 
17821 
  def __repr__(self):
17822 
    L = ['%s=%r' % (key, value)
17823 
      for key, value in self.__dict__.iteritems()]
17824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17825 
 
17826 
  def __eq__(self, other):
17827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17828 
 
17829 
  def __ne__(self, other):
17830 
    return not (self == other)
17831 
 
4607 rajveer 17832 
class getSlippedSippingDateOrders_args:
17833 
 
17834 
  thrift_spec = (
17835 
  )
17836 
 
17837 
  def read(self, iprot):
17838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17840 
      return
17841 
    iprot.readStructBegin()
17842 
    while True:
17843 
      (fname, ftype, fid) = iprot.readFieldBegin()
17844 
      if ftype == TType.STOP:
17845 
        break
17846 
      else:
17847 
        iprot.skip(ftype)
17848 
      iprot.readFieldEnd()
17849 
    iprot.readStructEnd()
17850 
 
17851 
  def write(self, oprot):
17852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17854 
      return
17855 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17856 
    oprot.writeFieldStop()
17857 
    oprot.writeStructEnd()
17858 
 
17859 
  def validate(self):
17860 
    return
17861 
 
17862 
 
17863 
  def __repr__(self):
17864 
    L = ['%s=%r' % (key, value)
17865 
      for key, value in self.__dict__.iteritems()]
17866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17867 
 
17868 
  def __eq__(self, other):
17869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17870 
 
17871 
  def __ne__(self, other):
17872 
    return not (self == other)
17873 
 
17874 
class getSlippedSippingDateOrders_result:
17875 
  """
17876 
  Attributes:
17877 
   - success
17878 
   - ex
17879 
  """
17880 
 
17881 
  thrift_spec = (
17882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17884 
  )
17885 
 
17886 
  def __init__(self, success=None, ex=None,):
17887 
    self.success = success
17888 
    self.ex = ex
17889 
 
17890 
  def read(self, iprot):
17891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17893 
      return
17894 
    iprot.readStructBegin()
17895 
    while True:
17896 
      (fname, ftype, fid) = iprot.readFieldBegin()
17897 
      if ftype == TType.STOP:
17898 
        break
17899 
      if fid == 0:
17900 
        if ftype == TType.LIST:
17901 
          self.success = []
4757 mandeep.dh 17902 
          (_etype310, _size307) = iprot.readListBegin()
17903 
          for _i311 in xrange(_size307):
17904 
            _elem312 = Order()
17905 
            _elem312.read(iprot)
17906 
            self.success.append(_elem312)
4607 rajveer 17907 
          iprot.readListEnd()
17908 
        else:
17909 
          iprot.skip(ftype)
17910 
      elif fid == 1:
17911 
        if ftype == TType.STRUCT:
17912 
          self.ex = TransactionServiceException()
17913 
          self.ex.read(iprot)
17914 
        else:
17915 
          iprot.skip(ftype)
17916 
      else:
17917 
        iprot.skip(ftype)
17918 
      iprot.readFieldEnd()
17919 
    iprot.readStructEnd()
17920 
 
17921 
  def write(self, oprot):
17922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17924 
      return
17925 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17926 
    if self.success is not None:
17927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17929 
      for iter313 in self.success:
17930 
        iter313.write(oprot)
4607 rajveer 17931 
      oprot.writeListEnd()
17932 
      oprot.writeFieldEnd()
17933 
    if self.ex is not None:
17934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17935 
      self.ex.write(oprot)
17936 
      oprot.writeFieldEnd()
17937 
    oprot.writeFieldStop()
17938 
    oprot.writeStructEnd()
17939 
 
17940 
  def validate(self):
17941 
    return
17942 
 
17943 
 
17944 
  def __repr__(self):
17945 
    L = ['%s=%r' % (key, value)
17946 
      for key, value in self.__dict__.iteritems()]
17947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17948 
 
17949 
  def __eq__(self, other):
17950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17951 
 
17952 
  def __ne__(self, other):
17953 
    return not (self == other)
17954 
 
4709 rajveer 17955 
class getCancelledOrders_args:
17956 
  """
17957 
  Attributes:
17958 
   - cancelDateFrom
17959 
   - cancelDateTo
17960 
  """
17961 
 
17962 
  thrift_spec = (
17963 
    None, # 0
17964 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
17965 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
17966 
  )
17967 
 
17968 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
17969 
    self.cancelDateFrom = cancelDateFrom
17970 
    self.cancelDateTo = cancelDateTo
17971 
 
17972 
  def read(self, iprot):
17973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17975 
      return
17976 
    iprot.readStructBegin()
17977 
    while True:
17978 
      (fname, ftype, fid) = iprot.readFieldBegin()
17979 
      if ftype == TType.STOP:
17980 
        break
17981 
      if fid == 1:
17982 
        if ftype == TType.I64:
17983 
          self.cancelDateFrom = iprot.readI64();
17984 
        else:
17985 
          iprot.skip(ftype)
17986 
      elif fid == 2:
17987 
        if ftype == TType.I64:
17988 
          self.cancelDateTo = iprot.readI64();
17989 
        else:
17990 
          iprot.skip(ftype)
17991 
      else:
17992 
        iprot.skip(ftype)
17993 
      iprot.readFieldEnd()
17994 
    iprot.readStructEnd()
17995 
 
17996 
  def write(self, oprot):
17997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17999 
      return
18000 
    oprot.writeStructBegin('getCancelledOrders_args')
18001 
    if self.cancelDateFrom is not None:
18002 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18003 
      oprot.writeI64(self.cancelDateFrom)
18004 
      oprot.writeFieldEnd()
18005 
    if self.cancelDateTo is not None:
18006 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18007 
      oprot.writeI64(self.cancelDateTo)
18008 
      oprot.writeFieldEnd()
18009 
    oprot.writeFieldStop()
18010 
    oprot.writeStructEnd()
18011 
 
18012 
  def validate(self):
18013 
    return
18014 
 
18015 
 
18016 
  def __repr__(self):
18017 
    L = ['%s=%r' % (key, value)
18018 
      for key, value in self.__dict__.iteritems()]
18019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18020 
 
18021 
  def __eq__(self, other):
18022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18023 
 
18024 
  def __ne__(self, other):
18025 
    return not (self == other)
18026 
 
18027 
class getCancelledOrders_result:
18028 
  """
18029 
  Attributes:
18030 
   - success
18031 
   - ex
18032 
  """
18033 
 
18034 
  thrift_spec = (
18035 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18037 
  )
18038 
 
18039 
  def __init__(self, success=None, ex=None,):
18040 
    self.success = success
18041 
    self.ex = ex
18042 
 
18043 
  def read(self, iprot):
18044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18046 
      return
18047 
    iprot.readStructBegin()
18048 
    while True:
18049 
      (fname, ftype, fid) = iprot.readFieldBegin()
18050 
      if ftype == TType.STOP:
18051 
        break
18052 
      if fid == 0:
18053 
        if ftype == TType.LIST:
18054 
          self.success = []
4757 mandeep.dh 18055 
          (_etype317, _size314) = iprot.readListBegin()
18056 
          for _i318 in xrange(_size314):
18057 
            _elem319 = Order()
18058 
            _elem319.read(iprot)
18059 
            self.success.append(_elem319)
4709 rajveer 18060 
          iprot.readListEnd()
18061 
        else:
18062 
          iprot.skip(ftype)
18063 
      elif fid == 1:
18064 
        if ftype == TType.STRUCT:
18065 
          self.ex = TransactionServiceException()
18066 
          self.ex.read(iprot)
18067 
        else:
18068 
          iprot.skip(ftype)
18069 
      else:
18070 
        iprot.skip(ftype)
18071 
      iprot.readFieldEnd()
18072 
    iprot.readStructEnd()
18073 
 
18074 
  def write(self, oprot):
18075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18077 
      return
18078 
    oprot.writeStructBegin('getCancelledOrders_result')
18079 
    if self.success is not None:
18080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18081 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 18082 
      for iter320 in self.success:
18083 
        iter320.write(oprot)
4709 rajveer 18084 
      oprot.writeListEnd()
18085 
      oprot.writeFieldEnd()
18086 
    if self.ex is not None:
18087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18088 
      self.ex.write(oprot)
18089 
      oprot.writeFieldEnd()
18090 
    oprot.writeFieldStop()
18091 
    oprot.writeStructEnd()
18092 
 
18093 
  def validate(self):
18094 
    return
18095 
 
18096 
 
18097 
  def __repr__(self):
18098 
    L = ['%s=%r' % (key, value)
18099 
      for key, value in self.__dict__.iteritems()]
18100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18101 
 
18102 
  def __eq__(self, other):
18103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18104 
 
18105 
  def __ne__(self, other):
18106 
    return not (self == other)
18107 
 
4600 varun.gupt 18108 
class saveBluedartSettlements_args:
18109 
  """
18110 
  Attributes:
18111 
   - mapAWBAndAmount
18112 
  """
18113 
 
18114 
  thrift_spec = (
18115 
    None, # 0
18116 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18117 
  )
18118 
 
18119 
  def __init__(self, mapAWBAndAmount=None,):
18120 
    self.mapAWBAndAmount = mapAWBAndAmount
18121 
 
18122 
  def read(self, iprot):
18123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18125 
      return
18126 
    iprot.readStructBegin()
18127 
    while True:
18128 
      (fname, ftype, fid) = iprot.readFieldBegin()
18129 
      if ftype == TType.STOP:
18130 
        break
18131 
      if fid == 1:
18132 
        if ftype == TType.MAP:
18133 
          self.mapAWBAndAmount = {}
4757 mandeep.dh 18134 
          (_ktype322, _vtype323, _size321 ) = iprot.readMapBegin()
18135 
          for _i325 in xrange(_size321):
18136 
            _key326 = iprot.readI64();
18137 
            _val327 = iprot.readDouble();
18138 
            self.mapAWBAndAmount[_key326] = _val327
4600 varun.gupt 18139 
          iprot.readMapEnd()
18140 
        else:
18141 
          iprot.skip(ftype)
18142 
      else:
18143 
        iprot.skip(ftype)
18144 
      iprot.readFieldEnd()
18145 
    iprot.readStructEnd()
18146 
 
18147 
  def write(self, oprot):
18148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18150 
      return
18151 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18152 
    if self.mapAWBAndAmount is not None:
18153 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18154 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4757 mandeep.dh 18155 
      for kiter328,viter329 in self.mapAWBAndAmount.items():
18156 
        oprot.writeI64(kiter328)
18157 
        oprot.writeDouble(viter329)
4600 varun.gupt 18158 
      oprot.writeMapEnd()
18159 
      oprot.writeFieldEnd()
18160 
    oprot.writeFieldStop()
18161 
    oprot.writeStructEnd()
18162 
 
18163 
  def validate(self):
18164 
    return
18165 
 
18166 
 
18167 
  def __repr__(self):
18168 
    L = ['%s=%r' % (key, value)
18169 
      for key, value in self.__dict__.iteritems()]
18170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18171 
 
18172 
  def __eq__(self, other):
18173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18174 
 
18175 
  def __ne__(self, other):
18176 
    return not (self == other)
18177 
 
18178 
class saveBluedartSettlements_result:
18179 
  """
18180 
  Attributes:
18181 
   - ex
18182 
  """
18183 
 
18184 
  thrift_spec = (
18185 
    None, # 0
18186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18187 
  )
18188 
 
18189 
  def __init__(self, ex=None,):
18190 
    self.ex = ex
18191 
 
18192 
  def read(self, iprot):
18193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18195 
      return
18196 
    iprot.readStructBegin()
18197 
    while True:
18198 
      (fname, ftype, fid) = iprot.readFieldBegin()
18199 
      if ftype == TType.STOP:
18200 
        break
18201 
      if fid == 1:
18202 
        if ftype == TType.STRUCT:
18203 
          self.ex = TransactionServiceException()
18204 
          self.ex.read(iprot)
18205 
        else:
18206 
          iprot.skip(ftype)
18207 
      else:
18208 
        iprot.skip(ftype)
18209 
      iprot.readFieldEnd()
18210 
    iprot.readStructEnd()
18211 
 
18212 
  def write(self, oprot):
18213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18215 
      return
18216 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18217 
    if self.ex is not None:
18218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18219 
      self.ex.write(oprot)
18220 
      oprot.writeFieldEnd()
18221 
    oprot.writeFieldStop()
18222 
    oprot.writeStructEnd()
18223 
 
18224 
  def validate(self):
18225 
    return
18226 
 
18227 
 
18228 
  def __repr__(self):
18229 
    L = ['%s=%r' % (key, value)
18230 
      for key, value in self.__dict__.iteritems()]
18231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18232 
 
18233 
  def __eq__(self, other):
18234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18235 
 
18236 
  def __ne__(self, other):
18237 
    return not (self == other)
18238 
 
18239 
class savePaymentSettlements_args:
18240 
  """
18241 
  Attributes:
18242 
   - settlementDate
18243 
   - paymentGatewayId
18244 
   - paymentId
18245 
   - serviceTax
18246 
   - otherCharges
18247 
   - netCollection
18248 
  """
18249 
 
18250 
  thrift_spec = (
18251 
    None, # 0
18252 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18253 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18254 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18255 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18256 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18257 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18258 
  )
18259 
 
18260 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18261 
    self.settlementDate = settlementDate
18262 
    self.paymentGatewayId = paymentGatewayId
18263 
    self.paymentId = paymentId
18264 
    self.serviceTax = serviceTax
18265 
    self.otherCharges = otherCharges
18266 
    self.netCollection = netCollection
18267 
 
18268 
  def read(self, iprot):
18269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18271 
      return
18272 
    iprot.readStructBegin()
18273 
    while True:
18274 
      (fname, ftype, fid) = iprot.readFieldBegin()
18275 
      if ftype == TType.STOP:
18276 
        break
18277 
      if fid == 1:
18278 
        if ftype == TType.I64:
18279 
          self.settlementDate = iprot.readI64();
18280 
        else:
18281 
          iprot.skip(ftype)
18282 
      elif fid == 2:
18283 
        if ftype == TType.I64:
18284 
          self.paymentGatewayId = iprot.readI64();
18285 
        else:
18286 
          iprot.skip(ftype)
18287 
      elif fid == 3:
18288 
        if ftype == TType.I64:
18289 
          self.paymentId = iprot.readI64();
18290 
        else:
18291 
          iprot.skip(ftype)
18292 
      elif fid == 4:
18293 
        if ftype == TType.DOUBLE:
18294 
          self.serviceTax = iprot.readDouble();
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      elif fid == 5:
18298 
        if ftype == TType.DOUBLE:
18299 
          self.otherCharges = iprot.readDouble();
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      elif fid == 6:
18303 
        if ftype == TType.DOUBLE:
18304 
          self.netCollection = iprot.readDouble();
18305 
        else:
18306 
          iprot.skip(ftype)
18307 
      else:
18308 
        iprot.skip(ftype)
18309 
      iprot.readFieldEnd()
18310 
    iprot.readStructEnd()
18311 
 
18312 
  def write(self, oprot):
18313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18315 
      return
18316 
    oprot.writeStructBegin('savePaymentSettlements_args')
18317 
    if self.settlementDate is not None:
18318 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18319 
      oprot.writeI64(self.settlementDate)
18320 
      oprot.writeFieldEnd()
18321 
    if self.paymentGatewayId is not None:
18322 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18323 
      oprot.writeI64(self.paymentGatewayId)
18324 
      oprot.writeFieldEnd()
18325 
    if self.paymentId is not None:
18326 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18327 
      oprot.writeI64(self.paymentId)
18328 
      oprot.writeFieldEnd()
18329 
    if self.serviceTax is not None:
18330 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18331 
      oprot.writeDouble(self.serviceTax)
18332 
      oprot.writeFieldEnd()
18333 
    if self.otherCharges is not None:
18334 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18335 
      oprot.writeDouble(self.otherCharges)
18336 
      oprot.writeFieldEnd()
18337 
    if self.netCollection is not None:
18338 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18339 
      oprot.writeDouble(self.netCollection)
18340 
      oprot.writeFieldEnd()
18341 
    oprot.writeFieldStop()
18342 
    oprot.writeStructEnd()
18343 
 
18344 
  def validate(self):
18345 
    return
18346 
 
18347 
 
18348 
  def __repr__(self):
18349 
    L = ['%s=%r' % (key, value)
18350 
      for key, value in self.__dict__.iteritems()]
18351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18352 
 
18353 
  def __eq__(self, other):
18354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18355 
 
18356 
  def __ne__(self, other):
18357 
    return not (self == other)
18358 
 
18359 
class savePaymentSettlements_result:
18360 
  """
18361 
  Attributes:
18362 
   - ex
18363 
  """
18364 
 
18365 
  thrift_spec = (
18366 
    None, # 0
18367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18368 
  )
18369 
 
18370 
  def __init__(self, ex=None,):
18371 
    self.ex = ex
18372 
 
18373 
  def read(self, iprot):
18374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18376 
      return
18377 
    iprot.readStructBegin()
18378 
    while True:
18379 
      (fname, ftype, fid) = iprot.readFieldBegin()
18380 
      if ftype == TType.STOP:
18381 
        break
18382 
      if fid == 1:
18383 
        if ftype == TType.STRUCT:
18384 
          self.ex = TransactionServiceException()
18385 
          self.ex.read(iprot)
18386 
        else:
18387 
          iprot.skip(ftype)
18388 
      else:
18389 
        iprot.skip(ftype)
18390 
      iprot.readFieldEnd()
18391 
    iprot.readStructEnd()
18392 
 
18393 
  def write(self, oprot):
18394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18396 
      return
18397 
    oprot.writeStructBegin('savePaymentSettlements_result')
18398 
    if self.ex is not None:
18399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18400 
      self.ex.write(oprot)
18401 
      oprot.writeFieldEnd()
18402 
    oprot.writeFieldStop()
18403 
    oprot.writeStructEnd()
18404 
 
18405 
  def validate(self):
18406 
    return
18407 
 
18408 
 
18409 
  def __repr__(self):
18410 
    L = ['%s=%r' % (key, value)
18411 
      for key, value in self.__dict__.iteritems()]
18412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18413 
 
18414 
  def __eq__(self, other):
18415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18416 
 
18417 
  def __ne__(self, other):
18418 
    return not (self == other)
18419 
 
18420 
class saveEBSSettlementSummary_args:
18421 
  """
18422 
  Attributes:
18423 
   - settlementId
18424 
   - settlementDate
18425 
   - transactionDateFrom
18426 
   - transactionDateTo
18427 
   - amount
18428 
  """
18429 
 
18430 
  thrift_spec = (
18431 
    None, # 0
18432 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18433 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18434 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18435 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18436 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18437 
  )
18438 
 
18439 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18440 
    self.settlementId = settlementId
18441 
    self.settlementDate = settlementDate
18442 
    self.transactionDateFrom = transactionDateFrom
18443 
    self.transactionDateTo = transactionDateTo
18444 
    self.amount = amount
18445 
 
18446 
  def read(self, iprot):
18447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18449 
      return
18450 
    iprot.readStructBegin()
18451 
    while True:
18452 
      (fname, ftype, fid) = iprot.readFieldBegin()
18453 
      if ftype == TType.STOP:
18454 
        break
18455 
      if fid == 1:
18456 
        if ftype == TType.I64:
18457 
          self.settlementId = iprot.readI64();
18458 
        else:
18459 
          iprot.skip(ftype)
18460 
      elif fid == 2:
18461 
        if ftype == TType.I64:
18462 
          self.settlementDate = iprot.readI64();
18463 
        else:
18464 
          iprot.skip(ftype)
18465 
      elif fid == 3:
18466 
        if ftype == TType.I64:
18467 
          self.transactionDateFrom = iprot.readI64();
18468 
        else:
18469 
          iprot.skip(ftype)
18470 
      elif fid == 4:
18471 
        if ftype == TType.I64:
18472 
          self.transactionDateTo = iprot.readI64();
18473 
        else:
18474 
          iprot.skip(ftype)
18475 
      elif fid == 5:
18476 
        if ftype == TType.DOUBLE:
18477 
          self.amount = iprot.readDouble();
18478 
        else:
18479 
          iprot.skip(ftype)
18480 
      else:
18481 
        iprot.skip(ftype)
18482 
      iprot.readFieldEnd()
18483 
    iprot.readStructEnd()
18484 
 
18485 
  def write(self, oprot):
18486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18488 
      return
18489 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18490 
    if self.settlementId is not None:
18491 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18492 
      oprot.writeI64(self.settlementId)
18493 
      oprot.writeFieldEnd()
18494 
    if self.settlementDate is not None:
18495 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18496 
      oprot.writeI64(self.settlementDate)
18497 
      oprot.writeFieldEnd()
18498 
    if self.transactionDateFrom is not None:
18499 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18500 
      oprot.writeI64(self.transactionDateFrom)
18501 
      oprot.writeFieldEnd()
18502 
    if self.transactionDateTo is not None:
18503 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18504 
      oprot.writeI64(self.transactionDateTo)
18505 
      oprot.writeFieldEnd()
18506 
    if self.amount is not None:
18507 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18508 
      oprot.writeDouble(self.amount)
18509 
      oprot.writeFieldEnd()
18510 
    oprot.writeFieldStop()
18511 
    oprot.writeStructEnd()
18512 
 
18513 
  def validate(self):
18514 
    return
18515 
 
18516 
 
18517 
  def __repr__(self):
18518 
    L = ['%s=%r' % (key, value)
18519 
      for key, value in self.__dict__.iteritems()]
18520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18521 
 
18522 
  def __eq__(self, other):
18523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18524 
 
18525 
  def __ne__(self, other):
18526 
    return not (self == other)
18527 
 
18528 
class saveEBSSettlementSummary_result:
18529 
  """
18530 
  Attributes:
18531 
   - ex
18532 
  """
18533 
 
18534 
  thrift_spec = (
18535 
    None, # 0
18536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18537 
  )
18538 
 
18539 
  def __init__(self, ex=None,):
18540 
    self.ex = ex
18541 
 
18542 
  def read(self, iprot):
18543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18545 
      return
18546 
    iprot.readStructBegin()
18547 
    while True:
18548 
      (fname, ftype, fid) = iprot.readFieldBegin()
18549 
      if ftype == TType.STOP:
18550 
        break
18551 
      if fid == 1:
18552 
        if ftype == TType.STRUCT:
18553 
          self.ex = TransactionServiceException()
18554 
          self.ex.read(iprot)
18555 
        else:
18556 
          iprot.skip(ftype)
18557 
      else:
18558 
        iprot.skip(ftype)
18559 
      iprot.readFieldEnd()
18560 
    iprot.readStructEnd()
18561 
 
18562 
  def write(self, oprot):
18563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18565 
      return
18566 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18567 
    if self.ex is not None:
18568 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18569 
      self.ex.write(oprot)
18570 
      oprot.writeFieldEnd()
18571 
    oprot.writeFieldStop()
18572 
    oprot.writeStructEnd()
18573 
 
18574 
  def validate(self):
18575 
    return
18576 
 
18577 
 
18578 
  def __repr__(self):
18579 
    L = ['%s=%r' % (key, value)
18580 
      for key, value in self.__dict__.iteritems()]
18581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18582 
 
18583 
  def __eq__(self, other):
18584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18585 
 
18586 
  def __ne__(self, other):
18587 
    return not (self == other)
18588 
 
18589 
class getSettlementForPaymentId_args:
18590 
  """
18591 
  Attributes:
18592 
   - paymentId
18593 
  """
18594 
 
18595 
  thrift_spec = (
18596 
    None, # 0
18597 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18598 
  )
18599 
 
18600 
  def __init__(self, paymentId=None,):
18601 
    self.paymentId = paymentId
18602 
 
18603 
  def read(self, iprot):
18604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18606 
      return
18607 
    iprot.readStructBegin()
18608 
    while True:
18609 
      (fname, ftype, fid) = iprot.readFieldBegin()
18610 
      if ftype == TType.STOP:
18611 
        break
18612 
      if fid == 1:
18613 
        if ftype == TType.I64:
18614 
          self.paymentId = iprot.readI64();
18615 
        else:
18616 
          iprot.skip(ftype)
18617 
      else:
18618 
        iprot.skip(ftype)
18619 
      iprot.readFieldEnd()
18620 
    iprot.readStructEnd()
18621 
 
18622 
  def write(self, oprot):
18623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18625 
      return
18626 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18627 
    if self.paymentId is not None:
18628 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18629 
      oprot.writeI64(self.paymentId)
18630 
      oprot.writeFieldEnd()
18631 
    oprot.writeFieldStop()
18632 
    oprot.writeStructEnd()
18633 
 
18634 
  def validate(self):
18635 
    return
18636 
 
18637 
 
18638 
  def __repr__(self):
18639 
    L = ['%s=%r' % (key, value)
18640 
      for key, value in self.__dict__.iteritems()]
18641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18642 
 
18643 
  def __eq__(self, other):
18644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18645 
 
18646 
  def __ne__(self, other):
18647 
    return not (self == other)
18648 
 
18649 
class getSettlementForPaymentId_result:
18650 
  """
18651 
  Attributes:
18652 
   - success
18653 
   - ex
18654 
  """
18655 
 
18656 
  thrift_spec = (
18657 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18659 
  )
18660 
 
18661 
  def __init__(self, success=None, ex=None,):
18662 
    self.success = success
18663 
    self.ex = ex
18664 
 
18665 
  def read(self, iprot):
18666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18668 
      return
18669 
    iprot.readStructBegin()
18670 
    while True:
18671 
      (fname, ftype, fid) = iprot.readFieldBegin()
18672 
      if ftype == TType.STOP:
18673 
        break
18674 
      if fid == 0:
18675 
        if ftype == TType.STRUCT:
18676 
          self.success = PaymentSettlement()
18677 
          self.success.read(iprot)
18678 
        else:
18679 
          iprot.skip(ftype)
18680 
      elif fid == 1:
18681 
        if ftype == TType.STRUCT:
18682 
          self.ex = TransactionServiceException()
18683 
          self.ex.read(iprot)
18684 
        else:
18685 
          iprot.skip(ftype)
18686 
      else:
18687 
        iprot.skip(ftype)
18688 
      iprot.readFieldEnd()
18689 
    iprot.readStructEnd()
18690 
 
18691 
  def write(self, oprot):
18692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18694 
      return
18695 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18696 
    if self.success is not None:
18697 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18698 
      self.success.write(oprot)
18699 
      oprot.writeFieldEnd()
18700 
    if self.ex is not None:
18701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18702 
      self.ex.write(oprot)
18703 
      oprot.writeFieldEnd()
18704 
    oprot.writeFieldStop()
18705 
    oprot.writeStructEnd()
18706 
 
18707 
  def validate(self):
18708 
    return
18709 
 
18710 
 
18711 
  def __repr__(self):
18712 
    L = ['%s=%r' % (key, value)
18713 
      for key, value in self.__dict__.iteritems()]
18714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18715 
 
18716 
  def __eq__(self, other):
18717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18718 
 
18719 
  def __ne__(self, other):
18720 
    return not (self == other)
18721 
 
18722 
class getEBSSettlementSummaries_args:
18723 
 
18724 
  thrift_spec = (
18725 
  )
18726 
 
18727 
  def read(self, iprot):
18728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18730 
      return
18731 
    iprot.readStructBegin()
18732 
    while True:
18733 
      (fname, ftype, fid) = iprot.readFieldBegin()
18734 
      if ftype == TType.STOP:
18735 
        break
18736 
      else:
18737 
        iprot.skip(ftype)
18738 
      iprot.readFieldEnd()
18739 
    iprot.readStructEnd()
18740 
 
18741 
  def write(self, oprot):
18742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18744 
      return
18745 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18746 
    oprot.writeFieldStop()
18747 
    oprot.writeStructEnd()
18748 
 
18749 
  def validate(self):
18750 
    return
18751 
 
18752 
 
18753 
  def __repr__(self):
18754 
    L = ['%s=%r' % (key, value)
18755 
      for key, value in self.__dict__.iteritems()]
18756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18757 
 
18758 
  def __eq__(self, other):
18759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18760 
 
18761 
  def __ne__(self, other):
18762 
    return not (self == other)
18763 
 
18764 
class getEBSSettlementSummaries_result:
18765 
  """
18766 
  Attributes:
18767 
   - success
18768 
   - ex
18769 
  """
18770 
 
18771 
  thrift_spec = (
18772 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18774 
  )
18775 
 
18776 
  def __init__(self, success=None, ex=None,):
18777 
    self.success = success
18778 
    self.ex = ex
18779 
 
18780 
  def read(self, iprot):
18781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18783 
      return
18784 
    iprot.readStructBegin()
18785 
    while True:
18786 
      (fname, ftype, fid) = iprot.readFieldBegin()
18787 
      if ftype == TType.STOP:
18788 
        break
18789 
      if fid == 0:
18790 
        if ftype == TType.MAP:
18791 
          self.success = {}
4757 mandeep.dh 18792 
          (_ktype331, _vtype332, _size330 ) = iprot.readMapBegin()
18793 
          for _i334 in xrange(_size330):
18794 
            _key335 = iprot.readI64();
18795 
            _val336 = iprot.readString();
18796 
            self.success[_key335] = _val336
4600 varun.gupt 18797 
          iprot.readMapEnd()
18798 
        else:
18799 
          iprot.skip(ftype)
18800 
      elif fid == 1:
18801 
        if ftype == TType.STRUCT:
18802 
          self.ex = TransactionServiceException()
18803 
          self.ex.read(iprot)
18804 
        else:
18805 
          iprot.skip(ftype)
18806 
      else:
18807 
        iprot.skip(ftype)
18808 
      iprot.readFieldEnd()
18809 
    iprot.readStructEnd()
18810 
 
18811 
  def write(self, oprot):
18812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18814 
      return
18815 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18816 
    if self.success is not None:
18817 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18818 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4757 mandeep.dh 18819 
      for kiter337,viter338 in self.success.items():
18820 
        oprot.writeI64(kiter337)
18821 
        oprot.writeString(viter338)
4600 varun.gupt 18822 
      oprot.writeMapEnd()
18823 
      oprot.writeFieldEnd()
18824 
    if self.ex is not None:
18825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18826 
      self.ex.write(oprot)
18827 
      oprot.writeFieldEnd()
18828 
    oprot.writeFieldStop()
18829 
    oprot.writeStructEnd()
18830 
 
18831 
  def validate(self):
18832 
    return
18833 
 
18834 
 
18835 
  def __repr__(self):
18836 
    L = ['%s=%r' % (key, value)
18837 
      for key, value in self.__dict__.iteritems()]
18838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18839 
 
18840 
  def __eq__(self, other):
18841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18842 
 
18843 
  def __ne__(self, other):
18844 
    return not (self == other)
18845 
 
18846 
class markEBSSettlementUploaded_args:
18847 
  """
18848 
  Attributes:
18849 
   - settlementId
18850 
  """
18851 
 
18852 
  thrift_spec = (
18853 
    None, # 0
18854 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18855 
  )
18856 
 
18857 
  def __init__(self, settlementId=None,):
18858 
    self.settlementId = settlementId
18859 
 
18860 
  def read(self, iprot):
18861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18863 
      return
18864 
    iprot.readStructBegin()
18865 
    while True:
18866 
      (fname, ftype, fid) = iprot.readFieldBegin()
18867 
      if ftype == TType.STOP:
18868 
        break
18869 
      if fid == 1:
18870 
        if ftype == TType.I64:
18871 
          self.settlementId = iprot.readI64();
18872 
        else:
18873 
          iprot.skip(ftype)
18874 
      else:
18875 
        iprot.skip(ftype)
18876 
      iprot.readFieldEnd()
18877 
    iprot.readStructEnd()
18878 
 
18879 
  def write(self, oprot):
18880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18882 
      return
18883 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18884 
    if self.settlementId is not None:
18885 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18886 
      oprot.writeI64(self.settlementId)
18887 
      oprot.writeFieldEnd()
18888 
    oprot.writeFieldStop()
18889 
    oprot.writeStructEnd()
18890 
 
18891 
  def validate(self):
18892 
    return
18893 
 
18894 
 
18895 
  def __repr__(self):
18896 
    L = ['%s=%r' % (key, value)
18897 
      for key, value in self.__dict__.iteritems()]
18898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18899 
 
18900 
  def __eq__(self, other):
18901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18902 
 
18903 
  def __ne__(self, other):
18904 
    return not (self == other)
18905 
 
18906 
class markEBSSettlementUploaded_result:
18907 
  """
18908 
  Attributes:
18909 
   - ex
18910 
  """
18911 
 
18912 
  thrift_spec = (
18913 
    None, # 0
18914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18915 
  )
18916 
 
18917 
  def __init__(self, ex=None,):
18918 
    self.ex = ex
18919 
 
18920 
  def read(self, iprot):
18921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18923 
      return
18924 
    iprot.readStructBegin()
18925 
    while True:
18926 
      (fname, ftype, fid) = iprot.readFieldBegin()
18927 
      if ftype == TType.STOP:
18928 
        break
18929 
      if fid == 1:
18930 
        if ftype == TType.STRUCT:
18931 
          self.ex = TransactionServiceException()
18932 
          self.ex.read(iprot)
18933 
        else:
18934 
          iprot.skip(ftype)
18935 
      else:
18936 
        iprot.skip(ftype)
18937 
      iprot.readFieldEnd()
18938 
    iprot.readStructEnd()
18939 
 
18940 
  def write(self, oprot):
18941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18943 
      return
18944 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18945 
    if self.ex is not None:
18946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18947 
      self.ex.write(oprot)
18948 
      oprot.writeFieldEnd()
18949 
    oprot.writeFieldStop()
18950 
    oprot.writeStructEnd()
18951 
 
18952 
  def validate(self):
18953 
    return
18954 
 
18955 
 
18956 
  def __repr__(self):
18957 
    L = ['%s=%r' % (key, value)
18958 
      for key, value in self.__dict__.iteritems()]
18959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18960 
 
18961 
  def __eq__(self, other):
18962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18963 
 
18964 
  def __ne__(self, other):
18965 
    return not (self == other)
18966 
 
18967 
class getEBSSettlementDate_args:
18968 
  """
18969 
  Attributes:
18970 
   - settlementId
18971 
  """
18972 
 
18973 
  thrift_spec = (
18974 
    None, # 0
18975 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18976 
  )
18977 
 
18978 
  def __init__(self, settlementId=None,):
18979 
    self.settlementId = settlementId
18980 
 
18981 
  def read(self, iprot):
18982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18984 
      return
18985 
    iprot.readStructBegin()
18986 
    while True:
18987 
      (fname, ftype, fid) = iprot.readFieldBegin()
18988 
      if ftype == TType.STOP:
18989 
        break
18990 
      if fid == 1:
18991 
        if ftype == TType.I64:
18992 
          self.settlementId = iprot.readI64();
18993 
        else:
18994 
          iprot.skip(ftype)
18995 
      else:
18996 
        iprot.skip(ftype)
18997 
      iprot.readFieldEnd()
18998 
    iprot.readStructEnd()
18999 
 
19000 
  def write(self, oprot):
19001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19003 
      return
19004 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19005 
    if self.settlementId is not None:
19006 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19007 
      oprot.writeI64(self.settlementId)
19008 
      oprot.writeFieldEnd()
19009 
    oprot.writeFieldStop()
19010 
    oprot.writeStructEnd()
19011 
 
19012 
  def validate(self):
19013 
    return
19014 
 
19015 
 
19016 
  def __repr__(self):
19017 
    L = ['%s=%r' % (key, value)
19018 
      for key, value in self.__dict__.iteritems()]
19019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19020 
 
19021 
  def __eq__(self, other):
19022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19023 
 
19024 
  def __ne__(self, other):
19025 
    return not (self == other)
19026 
 
19027 
class getEBSSettlementDate_result:
19028 
  """
19029 
  Attributes:
19030 
   - success
19031 
   - ex
19032 
  """
19033 
 
19034 
  thrift_spec = (
19035 
    (0, TType.I64, 'success', None, None, ), # 0
19036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19037 
  )
19038 
 
19039 
  def __init__(self, success=None, ex=None,):
19040 
    self.success = success
19041 
    self.ex = ex
19042 
 
19043 
  def read(self, iprot):
19044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19046 
      return
19047 
    iprot.readStructBegin()
19048 
    while True:
19049 
      (fname, ftype, fid) = iprot.readFieldBegin()
19050 
      if ftype == TType.STOP:
19051 
        break
19052 
      if fid == 0:
19053 
        if ftype == TType.I64:
19054 
          self.success = iprot.readI64();
19055 
        else:
19056 
          iprot.skip(ftype)
19057 
      elif fid == 1:
19058 
        if ftype == TType.STRUCT:
19059 
          self.ex = TransactionServiceException()
19060 
          self.ex.read(iprot)
19061 
        else:
19062 
          iprot.skip(ftype)
19063 
      else:
19064 
        iprot.skip(ftype)
19065 
      iprot.readFieldEnd()
19066 
    iprot.readStructEnd()
19067 
 
19068 
  def write(self, oprot):
19069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19071 
      return
19072 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19073 
    if self.success is not None:
19074 
      oprot.writeFieldBegin('success', TType.I64, 0)
19075 
      oprot.writeI64(self.success)
19076 
      oprot.writeFieldEnd()
19077 
    if self.ex is not None:
19078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19079 
      self.ex.write(oprot)
19080 
      oprot.writeFieldEnd()
19081 
    oprot.writeFieldStop()
19082 
    oprot.writeStructEnd()
19083 
 
19084 
  def validate(self):
19085 
    return
19086 
 
19087 
 
19088 
  def __repr__(self):
19089 
    L = ['%s=%r' % (key, value)
19090 
      for key, value in self.__dict__.iteritems()]
19091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19092 
 
19093 
  def __eq__(self, other):
19094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19095 
 
19096 
  def __ne__(self, other):
19097 
    return not (self == other)
4715 varun.gupt 19098 
 
19099 
class getSettlementsByDate_args:
19100 
  """
19101 
  Attributes:
19102 
   - settlementDateFrom
19103 
   - settlementDateTo
19104 
   - isRefund
19105 
  """
19106 
 
19107 
  thrift_spec = (
19108 
    None, # 0
19109 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19110 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19111 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19112 
  )
19113 
 
19114 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19115 
    self.settlementDateFrom = settlementDateFrom
19116 
    self.settlementDateTo = settlementDateTo
19117 
    self.isRefund = isRefund
19118 
 
19119 
  def read(self, iprot):
19120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19122 
      return
19123 
    iprot.readStructBegin()
19124 
    while True:
19125 
      (fname, ftype, fid) = iprot.readFieldBegin()
19126 
      if ftype == TType.STOP:
19127 
        break
19128 
      if fid == 1:
19129 
        if ftype == TType.I64:
19130 
          self.settlementDateFrom = iprot.readI64();
19131 
        else:
19132 
          iprot.skip(ftype)
19133 
      elif fid == 2:
19134 
        if ftype == TType.I64:
19135 
          self.settlementDateTo = iprot.readI64();
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      elif fid == 3:
19139 
        if ftype == TType.BOOL:
19140 
          self.isRefund = iprot.readBool();
19141 
        else:
19142 
          iprot.skip(ftype)
19143 
      else:
19144 
        iprot.skip(ftype)
19145 
      iprot.readFieldEnd()
19146 
    iprot.readStructEnd()
19147 
 
19148 
  def write(self, oprot):
19149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19151 
      return
19152 
    oprot.writeStructBegin('getSettlementsByDate_args')
19153 
    if self.settlementDateFrom is not None:
19154 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19155 
      oprot.writeI64(self.settlementDateFrom)
19156 
      oprot.writeFieldEnd()
19157 
    if self.settlementDateTo is not None:
19158 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19159 
      oprot.writeI64(self.settlementDateTo)
19160 
      oprot.writeFieldEnd()
19161 
    if self.isRefund is not None:
19162 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19163 
      oprot.writeBool(self.isRefund)
19164 
      oprot.writeFieldEnd()
19165 
    oprot.writeFieldStop()
19166 
    oprot.writeStructEnd()
19167 
 
19168 
  def validate(self):
19169 
    return
19170 
 
19171 
 
19172 
  def __repr__(self):
19173 
    L = ['%s=%r' % (key, value)
19174 
      for key, value in self.__dict__.iteritems()]
19175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19176 
 
19177 
  def __eq__(self, other):
19178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19179 
 
19180 
  def __ne__(self, other):
19181 
    return not (self == other)
19182 
 
19183 
class getSettlementsByDate_result:
19184 
  """
19185 
  Attributes:
19186 
   - success
19187 
   - ex
19188 
  """
19189 
 
19190 
  thrift_spec = (
19191 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19193 
  )
19194 
 
19195 
  def __init__(self, success=None, ex=None,):
19196 
    self.success = success
19197 
    self.ex = ex
19198 
 
19199 
  def read(self, iprot):
19200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19202 
      return
19203 
    iprot.readStructBegin()
19204 
    while True:
19205 
      (fname, ftype, fid) = iprot.readFieldBegin()
19206 
      if ftype == TType.STOP:
19207 
        break
19208 
      if fid == 0:
19209 
        if ftype == TType.LIST:
19210 
          self.success = []
4757 mandeep.dh 19211 
          (_etype342, _size339) = iprot.readListBegin()
19212 
          for _i343 in xrange(_size339):
19213 
            _elem344 = PaymentSettlement()
19214 
            _elem344.read(iprot)
19215 
            self.success.append(_elem344)
4715 varun.gupt 19216 
          iprot.readListEnd()
19217 
        else:
19218 
          iprot.skip(ftype)
19219 
      elif fid == 1:
19220 
        if ftype == TType.STRUCT:
19221 
          self.ex = TransactionServiceException()
19222 
          self.ex.read(iprot)
19223 
        else:
19224 
          iprot.skip(ftype)
19225 
      else:
19226 
        iprot.skip(ftype)
19227 
      iprot.readFieldEnd()
19228 
    iprot.readStructEnd()
19229 
 
19230 
  def write(self, oprot):
19231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19233 
      return
19234 
    oprot.writeStructBegin('getSettlementsByDate_result')
19235 
    if self.success is not None:
19236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19237 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 19238 
      for iter345 in self.success:
19239 
        iter345.write(oprot)
4715 varun.gupt 19240 
      oprot.writeListEnd()
19241 
      oprot.writeFieldEnd()
19242 
    if self.ex is not None:
19243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19244 
      self.ex.write(oprot)
19245 
      oprot.writeFieldEnd()
19246 
    oprot.writeFieldStop()
19247 
    oprot.writeStructEnd()
19248 
 
19249 
  def validate(self):
19250 
    return
19251 
 
19252 
 
19253 
  def __repr__(self):
19254 
    L = ['%s=%r' % (key, value)
19255 
      for key, value in self.__dict__.iteritems()]
19256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19257 
 
19258 
  def __eq__(self, other):
19259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19260 
 
19261 
  def __ne__(self, other):
19262 
    return not (self == other)
19263 
 
19264 
class getReshippedOrderIds_args:
19265 
  """
19266 
  Attributes:
19267 
   - orderIds
19268 
  """
19269 
 
19270 
  thrift_spec = (
19271 
    None, # 0
19272 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19273 
  )
19274 
 
19275 
  def __init__(self, orderIds=None,):
19276 
    self.orderIds = orderIds
19277 
 
19278 
  def read(self, iprot):
19279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19281 
      return
19282 
    iprot.readStructBegin()
19283 
    while True:
19284 
      (fname, ftype, fid) = iprot.readFieldBegin()
19285 
      if ftype == TType.STOP:
19286 
        break
19287 
      if fid == 1:
19288 
        if ftype == TType.LIST:
19289 
          self.orderIds = []
4757 mandeep.dh 19290 
          (_etype349, _size346) = iprot.readListBegin()
19291 
          for _i350 in xrange(_size346):
19292 
            _elem351 = iprot.readI64();
19293 
            self.orderIds.append(_elem351)
4715 varun.gupt 19294 
          iprot.readListEnd()
19295 
        else:
19296 
          iprot.skip(ftype)
19297 
      else:
19298 
        iprot.skip(ftype)
19299 
      iprot.readFieldEnd()
19300 
    iprot.readStructEnd()
19301 
 
19302 
  def write(self, oprot):
19303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19305 
      return
19306 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19307 
    if self.orderIds is not None:
19308 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19309 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4757 mandeep.dh 19310 
      for iter352 in self.orderIds:
19311 
        oprot.writeI64(iter352)
4715 varun.gupt 19312 
      oprot.writeListEnd()
19313 
      oprot.writeFieldEnd()
19314 
    oprot.writeFieldStop()
19315 
    oprot.writeStructEnd()
19316 
 
19317 
  def validate(self):
19318 
    return
19319 
 
19320 
 
19321 
  def __repr__(self):
19322 
    L = ['%s=%r' % (key, value)
19323 
      for key, value in self.__dict__.iteritems()]
19324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19325 
 
19326 
  def __eq__(self, other):
19327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19328 
 
19329 
  def __ne__(self, other):
19330 
    return not (self == other)
19331 
 
19332 
class getReshippedOrderIds_result:
19333 
  """
19334 
  Attributes:
19335 
   - success
19336 
   - ex
19337 
  """
19338 
 
19339 
  thrift_spec = (
19340 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19342 
  )
19343 
 
19344 
  def __init__(self, success=None, ex=None,):
19345 
    self.success = success
19346 
    self.ex = ex
19347 
 
19348 
  def read(self, iprot):
19349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19351 
      return
19352 
    iprot.readStructBegin()
19353 
    while True:
19354 
      (fname, ftype, fid) = iprot.readFieldBegin()
19355 
      if ftype == TType.STOP:
19356 
        break
19357 
      if fid == 0:
19358 
        if ftype == TType.LIST:
19359 
          self.success = []
4757 mandeep.dh 19360 
          (_etype356, _size353) = iprot.readListBegin()
19361 
          for _i357 in xrange(_size353):
19362 
            _elem358 = iprot.readI64();
19363 
            self.success.append(_elem358)
4715 varun.gupt 19364 
          iprot.readListEnd()
19365 
        else:
19366 
          iprot.skip(ftype)
19367 
      elif fid == 1:
19368 
        if ftype == TType.STRUCT:
19369 
          self.ex = TransactionServiceException()
19370 
          self.ex.read(iprot)
19371 
        else:
19372 
          iprot.skip(ftype)
19373 
      else:
19374 
        iprot.skip(ftype)
19375 
      iprot.readFieldEnd()
19376 
    iprot.readStructEnd()
19377 
 
19378 
  def write(self, oprot):
19379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19381 
      return
19382 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19383 
    if self.success is not None:
19384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19385 
      oprot.writeListBegin(TType.I64, len(self.success))
4757 mandeep.dh 19386 
      for iter359 in self.success:
19387 
        oprot.writeI64(iter359)
4715 varun.gupt 19388 
      oprot.writeListEnd()
19389 
      oprot.writeFieldEnd()
19390 
    if self.ex is not None:
19391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19392 
      self.ex.write(oprot)
19393 
      oprot.writeFieldEnd()
19394 
    oprot.writeFieldStop()
19395 
    oprot.writeStructEnd()
19396 
 
19397 
  def validate(self):
19398 
    return
19399 
 
19400 
 
19401 
  def __repr__(self):
19402 
    L = ['%s=%r' % (key, value)
19403 
      for key, value in self.__dict__.iteritems()]
19404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19405 
 
19406 
  def __eq__(self, other):
19407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19408 
 
19409 
  def __ne__(self, other):
19410 
    return not (self == other)
4757 mandeep.dh 19411 
 
19412 
class updateOrdersAsPORaised_args:
19413 
  """
19414 
  Attributes:
19415 
   - itemIdQuantityMap
19416 
   - purchaseOrderId
19417 
   - warehouseId
19418 
  """
19419 
 
19420 
  thrift_spec = (
19421 
    None, # 0
19422 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19423 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19424 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19425 
  )
19426 
 
19427 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19428 
    self.itemIdQuantityMap = itemIdQuantityMap
19429 
    self.purchaseOrderId = purchaseOrderId
19430 
    self.warehouseId = warehouseId
19431 
 
19432 
  def read(self, iprot):
19433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19435 
      return
19436 
    iprot.readStructBegin()
19437 
    while True:
19438 
      (fname, ftype, fid) = iprot.readFieldBegin()
19439 
      if ftype == TType.STOP:
19440 
        break
19441 
      if fid == 1:
19442 
        if ftype == TType.MAP:
19443 
          self.itemIdQuantityMap = {}
19444 
          (_ktype361, _vtype362, _size360 ) = iprot.readMapBegin()
19445 
          for _i364 in xrange(_size360):
19446 
            _key365 = iprot.readI64();
19447 
            _val366 = iprot.readI64();
19448 
            self.itemIdQuantityMap[_key365] = _val366
19449 
          iprot.readMapEnd()
19450 
        else:
19451 
          iprot.skip(ftype)
19452 
      elif fid == 2:
19453 
        if ftype == TType.I64:
19454 
          self.purchaseOrderId = iprot.readI64();
19455 
        else:
19456 
          iprot.skip(ftype)
19457 
      elif fid == 3:
19458 
        if ftype == TType.I64:
19459 
          self.warehouseId = iprot.readI64();
19460 
        else:
19461 
          iprot.skip(ftype)
19462 
      else:
19463 
        iprot.skip(ftype)
19464 
      iprot.readFieldEnd()
19465 
    iprot.readStructEnd()
19466 
 
19467 
  def write(self, oprot):
19468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19470 
      return
19471 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19472 
    if self.itemIdQuantityMap is not None:
19473 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19474 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
19475 
      for kiter367,viter368 in self.itemIdQuantityMap.items():
19476 
        oprot.writeI64(kiter367)
19477 
        oprot.writeI64(viter368)
19478 
      oprot.writeMapEnd()
19479 
      oprot.writeFieldEnd()
19480 
    if self.purchaseOrderId is not None:
19481 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19482 
      oprot.writeI64(self.purchaseOrderId)
19483 
      oprot.writeFieldEnd()
19484 
    if self.warehouseId is not None:
19485 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19486 
      oprot.writeI64(self.warehouseId)
19487 
      oprot.writeFieldEnd()
19488 
    oprot.writeFieldStop()
19489 
    oprot.writeStructEnd()
19490 
 
19491 
  def validate(self):
19492 
    return
19493 
 
19494 
 
19495 
  def __repr__(self):
19496 
    L = ['%s=%r' % (key, value)
19497 
      for key, value in self.__dict__.iteritems()]
19498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19499 
 
19500 
  def __eq__(self, other):
19501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19502 
 
19503 
  def __ne__(self, other):
19504 
    return not (self == other)
19505 
 
19506 
class updateOrdersAsPORaised_result:
19507 
  """
19508 
  Attributes:
19509 
   - ex
19510 
  """
19511 
 
19512 
  thrift_spec = (
19513 
    None, # 0
19514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19515 
  )
19516 
 
19517 
  def __init__(self, ex=None,):
19518 
    self.ex = ex
19519 
 
19520 
  def read(self, iprot):
19521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19523 
      return
19524 
    iprot.readStructBegin()
19525 
    while True:
19526 
      (fname, ftype, fid) = iprot.readFieldBegin()
19527 
      if ftype == TType.STOP:
19528 
        break
19529 
      if fid == 1:
19530 
        if ftype == TType.STRUCT:
19531 
          self.ex = TransactionServiceException()
19532 
          self.ex.read(iprot)
19533 
        else:
19534 
          iprot.skip(ftype)
19535 
      else:
19536 
        iprot.skip(ftype)
19537 
      iprot.readFieldEnd()
19538 
    iprot.readStructEnd()
19539 
 
19540 
  def write(self, oprot):
19541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19543 
      return
19544 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19545 
    if self.ex is not None:
19546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19547 
      self.ex.write(oprot)
19548 
      oprot.writeFieldEnd()
19549 
    oprot.writeFieldStop()
19550 
    oprot.writeStructEnd()
19551 
 
19552 
  def validate(self):
19553 
    return
19554 
 
19555 
 
19556 
  def __repr__(self):
19557 
    L = ['%s=%r' % (key, value)
19558 
      for key, value in self.__dict__.iteritems()]
19559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19560 
 
19561 
  def __eq__(self, other):
19562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19563 
 
19564 
  def __ne__(self, other):
19565 
    return not (self == other)