Subversion Repositories SmartDukaan

Rev

Rev 4709 | Rev 4715 | 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 
 
4658 mandeep.dh 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
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
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    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.
435 
    Returns the final flag status.
436 
    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 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4712 rajveer 443 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
444 
    """
445 
    Parameters:
446 
     - orderId
447 
     - deliveryTimestamp
448 
     - receiver
449 
    """
450 
    pass
451 
 
4454 rajveer 452 
  def markOrderDoaRequestReceived(self, orderId):
453 
    """
454 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
455 
 
456 
    Parameters:
457 
     - orderId
458 
    """
459 
    pass
460 
 
461 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
462 
    """
463 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
464 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
465 
 
466 
    Parameters:
467 
     - orderId
468 
     - isAuthorized
469 
    """
470 
    pass
471 
 
4488 rajveer 472 
  def markOrderReturnRequestReceived(self, orderId):
473 
    """
474 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
475 
 
476 
    Parameters:
477 
     - orderId
478 
    """
479 
    pass
480 
 
481 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
482 
    """
483 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
484 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
485 
 
486 
    Parameters:
487 
     - orderId
488 
     - isAuthorized
489 
    """
490 
    pass
491 
 
4579 rajveer 492 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 493 
    """
494 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 495 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
496 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 497 
    For any other status, it returns false.
498 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 499 
 
2536 chandransh 500 
    Parameters:
501 
     - orderId
4579 rajveer 502 
     - providerId
2536 chandransh 503 
    """
504 
    pass
505 
 
4602 rajveer 506 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 507 
    """
4452 rajveer 508 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 509 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
510 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
511 
    	3. Returns true
2591 chandransh 512 
    If the order is in any other status, it returns false.
2536 chandransh 513 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 514 
 
2536 chandransh 515 
    Parameters:
516 
     - orderId
517 
     - pickupNumber
4602 rajveer 518 
     - providerId
2536 chandransh 519 
    """
520 
    pass
521 
 
2764 chandransh 522 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
523 
    """
524 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
525 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 526 
 
2764 chandransh 527 
    Parameters:
528 
     - providerId
529 
     - pickupDetails
530 
    """
531 
    pass
532 
 
4479 rajveer 533 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 534 
    """
4452 rajveer 535 
    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 536 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 537 
    If the order is in any other state, it returns false.
538 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 539 
 
2591 chandransh 540 
    Parameters:
541 
     - orderId
4479 rajveer 542 
     - receiveCondition
2591 chandransh 543 
    """
544 
    pass
2536 chandransh 545 
 
2591 chandransh 546 
  def validateDoa(self, orderId, isValid):
547 
    """
4452 rajveer 548 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 549 
    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 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
555 
     - isValid
556 
    """
557 
    pass
558 
 
4495 rajveer 559 
  def validateReturnProduct(self, orderId, isUsable):
560 
    """
561 
    Parameters:
562 
     - orderId
563 
     - isUsable
564 
    """
565 
    pass
566 
 
2616 chandransh 567 
  def reshipOrder(self, orderId):
568 
    """
4484 rajveer 569 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 570 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 571 
    	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 572 
 
573 
    If the order is in DOA_CERT_VALID state, it does the following:
574 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
575 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 576 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 577 
 
2616 chandransh 578 
    Returns the id of the newly created order.
3431 rajveer 579 
 
2616 chandransh 580 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 581 
 
2616 chandransh 582 
    Parameters:
583 
     - orderId
584 
    """
585 
    pass
2591 chandransh 586 
 
3226 chandransh 587 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 588 
    """
4484 rajveer 589 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 590 
    	1. Creates a refund request for batch processing.
591 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 592 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 593 
 
2616 chandransh 594 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
595 
    	1. Creates a refund request for batch processing.
3226 chandransh 596 
    	2. Cancels the reservation of the item in the warehouse.
597 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 598 
 
3226 chandransh 599 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
600 
    	1. Cancels the reservation of the item in the warehouse.
601 
    	2. Marks the current order as CANCELED.
602 
 
603 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
604 
 
2616 chandransh 605 
    Returns True if it is successful, False otherwise.
3431 rajveer 606 
 
2616 chandransh 607 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 608 
 
2616 chandransh 609 
    Parameters:
610 
     - orderId
3226 chandransh 611 
     - refundedBy
612 
     - reason
2616 chandransh 613 
    """
614 
    pass
615 
 
2690 chandransh 616 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
617 
    """
618 
    Get all return orders created between the from and to dates for the given warehouse.
619 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 620 
 
2690 chandransh 621 
    Parameters:
622 
     - warehouseId
623 
     - fromDate
624 
     - toDate
625 
    """
626 
    pass
2616 chandransh 627 
 
2700 chandransh 628 
  def getReturnOrder(self, id):
629 
    """
630 
    Returns the ReturnOrder corresponding to the given id.
631 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 632 
 
2700 chandransh 633 
    Parameters:
634 
     - id
635 
    """
636 
    pass
637 
 
2690 chandransh 638 
  def processReturn(self, returnOrderId):
639 
    """
640 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 641 
 
2690 chandransh 642 
    Parameters:
643 
     - returnOrderId
644 
    """
645 
    pass
646 
 
2819 chandransh 647 
  def createPurchaseOrder(self, warehouseId):
648 
    """
4586 mandeep.dh 649 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
650 
    Returns the list of PO no. of the newly created purchase order.
651 
    Returns null if no new purchase order had to be created.
3431 rajveer 652 
 
2819 chandransh 653 
    Parameters:
654 
     - warehouseId
655 
    """
656 
    pass
2690 chandransh 657 
 
3451 chandransh 658 
  def updateWeight(self, orderId, weight):
659 
    """
660 
    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 661 
 
3451 chandransh 662 
    Parameters:
663 
     - orderId
664 
     - weight
665 
    """
666 
    pass
667 
 
3469 chandransh 668 
  def changeItem(self, orderId, itemId):
669 
    """
670 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
671 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 672 
 
3469 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - itemId
676 
    """
677 
    pass
678 
 
679 
  def shiftToWarehouse(self, orderId, warehouseId):
680 
    """
681 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
682 
 
683 
    Parameters:
684 
     - orderId
685 
     - warehouseId
686 
    """
687 
    pass
688 
 
4647 rajveer 689 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 690 
    """
691 
    Adds the given delay reason to the given order.
3986 chandransh 692 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 693 
    Raises an exception if no order with the given id can be found.
3469 chandransh 694 
 
3553 chandransh 695 
    Parameters:
696 
     - orderId
697 
     - delayReason
3986 chandransh 698 
     - furtherDelay
4647 rajveer 699 
     - delayReasonText
3553 chandransh 700 
    """
701 
    pass
702 
 
3956 chandransh 703 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
704 
    """
705 
    Marks the COD orders with given AWB nos. as having been processed.
706 
    Updates the captured amount for the corresponding payment.
3553 chandransh 707 
 
3956 chandransh 708 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
709 
    1. There is no order corresponding to an AWB number.
710 
    2. The captured amount for a payment exceeds the total payment.
711 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
712 
 
713 
    Parameters:
714 
     - collectedAmountMap
715 
     - xferBy
716 
     - xferTxnId
717 
     - xferDate
718 
    """
719 
    pass
720 
 
4008 mandeep.dh 721 
  def getTransactionsRequiringExtraProcessing(self, category):
722 
    """
4065 mandeep.dh 723 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 724 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 725 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 726 
 
4008 mandeep.dh 727 
    Parameters:
728 
     - category
729 
    """
730 
    pass
731 
 
732 
  def markTransactionAsProcessed(self, transactionId, category):
733 
    """
734 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 735 
    It essentially deletes the transaction id record for a particular
736 
    processing type category (if present) from DB.
737 
    This is currently used by CRM application.
4008 mandeep.dh 738 
 
739 
    Parameters:
740 
     - transactionId
741 
     - category
742 
    """
743 
    pass
744 
 
4018 chandransh 745 
  def getItemWiseRiskyOrdersCount(self, ):
746 
    """
747 
    Returns a map containing the number of risky orders keyed by item id. A risky order
748 
    is defined as one whose shipping date is about to expire.
749 
    """
750 
    pass
4008 mandeep.dh 751 
 
4295 varun.gupt 752 
  def getOrdersForItemIds(self, itemIds):
753 
    """
754 
    Returns a list of all orders which have items with given id
755 
 
756 
    Parameters:
757 
     - itemIds
758 
    """
759 
    pass
760 
 
4247 rajveer 761 
  def markOrderCancellationRequestReceived(self, orderId):
762 
    """
763 
    Mark order as cancellation request received. If customer sends request of cancellation of
764 
    a particular order, this method will be called. It will just change status of the order
765 
    depending on its current status. It also records the previous status, so that we can move
766 
    back to that status if cancellation request is denied.
4018 chandransh 767 
 
4247 rajveer 768 
    Parameters:
769 
     - orderId
770 
    """
771 
    pass
772 
 
773 
  def markOrderCancellationRequestConfirmed(self, orderId):
774 
    """
775 
    If we decide to to cancel order, CRM will call this method to move the status of order to
776 
    cancellation request confirmed. After this OM will be able to cancel the order.
777 
 
778 
    Parameters:
779 
     - orderId
780 
    """
781 
    pass
782 
 
783 
  def markOrderCancellationRequestDenied(self, orderId):
784 
    """
785 
    If we decide to not to cancel order, we will move the order ro previous status.
786 
 
787 
    Parameters:
788 
     - orderId
789 
    """
790 
    pass
791 
 
4258 rajveer 792 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 793 
    """
4258 rajveer 794 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
795 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 796 
 
797 
    Parameters:
4258 rajveer 798 
     - transactionId
4247 rajveer 799 
    """
800 
    pass
801 
 
4259 anupam.sin 802 
  def refundTransaction(self, transactionId, refundedBy, reason):
803 
    """
804 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
805 
    need to be cancelled
4247 rajveer 806 
 
4259 anupam.sin 807 
    Parameters:
808 
     - transactionId
809 
     - refundedBy
810 
     - reason
811 
    """
812 
    pass
813 
 
4324 mandeep.dh 814 
  def updateShipmentAddress(self, orderId, addressId):
815 
    """
816 
    Updates shipment address of an order. Delivery and shipping date estimates
817 
    etc. are also updated here.
818 
 
819 
    Throws TransactionServiceException in case address change is not
820 
    possible due to certain reasons such as new pincode in address is
821 
    not serviceable etc.
822 
 
823 
    Parameters:
824 
     - orderId
825 
     - addressId
826 
    """
827 
    pass
828 
 
4285 rajveer 829 
  def acceptOrdersForItemId(self, itemId, inventory):
830 
    """
831 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
832 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 833 
 
4285 rajveer 834 
    Parameters:
835 
     - itemId
836 
     - inventory
837 
    """
838 
    pass
839 
 
4369 rajveer 840 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 841 
    """
842 
    Parameters:
843 
     - vendorId
844 
     - itemId
845 
     - quantity
846 
     - estimate
4369 rajveer 847 
     - isReminder
4303 rajveer 848 
    """
849 
    pass
4285 rajveer 850 
 
4369 rajveer 851 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
861 
 
4369 rajveer 862 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 863 
    """
864 
    Parameters:
865 
     - vendorId
866 
     - itemId
867 
     - quantity
868 
     - estimate
4369 rajveer 869 
     - isReminder
4303 rajveer 870 
    """
871 
    pass
872 
 
4369 rajveer 873 
  def markOrdersAsTimeout(self, vendorId):
874 
    """
875 
    Parameters:
876 
     - vendorId
877 
    """
878 
    pass
4303 rajveer 879 
 
4662 rajveer 880 
  def markOrderAsLostInTransit(self, orderId):
881 
    """
882 
    Mark order as LOST_IN_TRANSIT
883 
 
884 
    Parameters:
885 
     - orderId
886 
    """
887 
    pass
888 
 
4386 anupam.sin 889 
  def getOrderForAwb(self, awb):
890 
    """
891 
    Returns the order corresponding to an AWB number
4369 rajveer 892 
 
4386 anupam.sin 893 
    Parameters:
894 
     - awb
895 
    """
896 
    pass
897 
 
4506 phani.kuma 898 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
899 
    """
900 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 901 
 
4506 phani.kuma 902 
    Parameters:
903 
     - logistics_provider_id
904 
     - order_status
905 
    """
906 
    pass
907 
 
4600 varun.gupt 908 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
909 
    """
910 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 911 
 
4600 varun.gupt 912 
    Parameters:
913 
     - vendorId
914 
     - billingDateFrom
915 
     - billingDateTo
916 
    """
917 
    pass
918 
 
4607 rajveer 919 
  def getSlippedSippingDateOrders(self, ):
920 
    pass
921 
 
4709 rajveer 922 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
923 
    """
924 
    Parameters:
925 
     - cancelDateFrom
926 
     - cancelDateTo
927 
    """
928 
    pass
929 
 
4600 varun.gupt 930 
  def saveBluedartSettlements(self, mapAWBAndAmount):
931 
    """
932 
    Parameters:
933 
     - mapAWBAndAmount
934 
    """
935 
    pass
936 
 
937 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
938 
    """
939 
    Parameters:
940 
     - settlementDate
941 
     - paymentGatewayId
942 
     - paymentId
943 
     - serviceTax
944 
     - otherCharges
945 
     - netCollection
946 
    """
947 
    pass
948 
 
949 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
950 
    """
951 
    Parameters:
952 
     - settlementId
953 
     - settlementDate
954 
     - transactionDateFrom
955 
     - transactionDateTo
956 
     - amount
957 
    """
958 
    pass
959 
 
960 
  def getSettlementForPaymentId(self, paymentId):
961 
    """
962 
    Parameters:
963 
     - paymentId
964 
    """
965 
    pass
966 
 
967 
  def getEBSSettlementSummaries(self, ):
968 
    pass
969 
 
970 
  def markEBSSettlementUploaded(self, settlementId):
971 
    """
972 
    Parameters:
973 
     - settlementId
974 
    """
975 
    pass
976 
 
977 
  def getEBSSettlementDate(self, settlementId):
978 
    """
979 
    Parameters:
980 
     - settlementId
981 
    """
982 
    pass
983 
 
984 
 
3376 rajveer 985 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 986 
  def __init__(self, iprot, oprot=None):
3376 rajveer 987 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 988 
 
989 
  def createTransaction(self, transaction):
990 
    """
991 
    Parameters:
992 
     - transaction
993 
    """
994 
    self.send_createTransaction(transaction)
132 ashish 995 
    return self.recv_createTransaction()
94 ashish 996 
 
997 
  def send_createTransaction(self, transaction):
998 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
999 
    args = createTransaction_args()
1000 
    args.transaction = transaction
1001 
    args.write(self._oprot)
1002 
    self._oprot.writeMessageEnd()
1003 
    self._oprot.trans.flush()
1004 
 
1005 
  def recv_createTransaction(self, ):
1006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1007 
    if mtype == TMessageType.EXCEPTION:
1008 
      x = TApplicationException()
1009 
      x.read(self._iprot)
1010 
      self._iprot.readMessageEnd()
1011 
      raise x
1012 
    result = createTransaction_result()
1013 
    result.read(self._iprot)
1014 
    self._iprot.readMessageEnd()
3431 rajveer 1015 
    if result.success is not None:
132 ashish 1016 
      return result.success
3431 rajveer 1017 
    if result.ex is not None:
94 ashish 1018 
      raise result.ex
132 ashish 1019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1020 
 
1021 
  def getTransaction(self, id):
1022 
    """
1023 
    Parameters:
1024 
     - id
1025 
    """
1026 
    self.send_getTransaction(id)
1027 
    return self.recv_getTransaction()
1028 
 
1029 
  def send_getTransaction(self, id):
1030 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1031 
    args = getTransaction_args()
1032 
    args.id = id
1033 
    args.write(self._oprot)
1034 
    self._oprot.writeMessageEnd()
1035 
    self._oprot.trans.flush()
1036 
 
1037 
  def recv_getTransaction(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 = getTransaction_result()
1045 
    result.read(self._iprot)
1046 
    self._iprot.readMessageEnd()
3431 rajveer 1047 
    if result.success is not None:
94 ashish 1048 
      return result.success
3431 rajveer 1049 
    if result.ex is not None:
94 ashish 1050 
      raise result.ex
1051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1052 
 
1053 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1054 
    """
1055 
    Parameters:
1056 
     - customerId
1057 
     - from_date
1058 
     - to_date
1059 
     - status
1060 
    """
1061 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1062 
    return self.recv_getTransactionsForCustomer()
1063 
 
1064 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1065 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1066 
    args = getTransactionsForCustomer_args()
1067 
    args.customerId = customerId
1068 
    args.from_date = from_date
1069 
    args.to_date = to_date
1070 
    args.status = status
1071 
    args.write(self._oprot)
1072 
    self._oprot.writeMessageEnd()
1073 
    self._oprot.trans.flush()
1074 
 
1075 
  def recv_getTransactionsForCustomer(self, ):
1076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1077 
    if mtype == TMessageType.EXCEPTION:
1078 
      x = TApplicationException()
1079 
      x.read(self._iprot)
1080 
      self._iprot.readMessageEnd()
1081 
      raise x
1082 
    result = getTransactionsForCustomer_result()
1083 
    result.read(self._iprot)
1084 
    self._iprot.readMessageEnd()
3431 rajveer 1085 
    if result.success is not None:
94 ashish 1086 
      return result.success
3431 rajveer 1087 
    if result.ex is not None:
94 ashish 1088 
      raise result.ex
1089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1090 
 
132 ashish 1091 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1092 
    """
1093 
    Parameters:
1094 
     - shoppingCartId
1095 
    """
1096 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1097 
    return self.recv_getTransactionsForShoppingCartId()
1098 
 
1099 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1100 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1101 
    args = getTransactionsForShoppingCartId_args()
1102 
    args.shoppingCartId = shoppingCartId
1103 
    args.write(self._oprot)
1104 
    self._oprot.writeMessageEnd()
1105 
    self._oprot.trans.flush()
1106 
 
1107 
  def recv_getTransactionsForShoppingCartId(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 = getTransactionsForShoppingCartId_result()
1115 
    result.read(self._iprot)
1116 
    self._iprot.readMessageEnd()
3431 rajveer 1117 
    if result.success is not None:
132 ashish 1118 
      return result.success
3431 rajveer 1119 
    if result.ex is not None:
132 ashish 1120 
      raise result.ex
1121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1122 
 
94 ashish 1123 
  def getTransactionStatus(self, transactionId):
1124 
    """
1125 
    Parameters:
1126 
     - transactionId
1127 
    """
1128 
    self.send_getTransactionStatus(transactionId)
1129 
    return self.recv_getTransactionStatus()
1130 
 
1131 
  def send_getTransactionStatus(self, transactionId):
1132 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1133 
    args = getTransactionStatus_args()
1134 
    args.transactionId = transactionId
1135 
    args.write(self._oprot)
1136 
    self._oprot.writeMessageEnd()
1137 
    self._oprot.trans.flush()
1138 
 
1139 
  def recv_getTransactionStatus(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 = getTransactionStatus_result()
1147 
    result.read(self._iprot)
1148 
    self._iprot.readMessageEnd()
3431 rajveer 1149 
    if result.success is not None:
94 ashish 1150 
      return result.success
3431 rajveer 1151 
    if result.ex is not None:
94 ashish 1152 
      raise result.ex
1153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1154 
 
1155 
  def changeTransactionStatus(self, transactionId, status, description):
1156 
    """
1157 
    Parameters:
1158 
     - transactionId
1159 
     - status
1160 
     - description
1161 
    """
1162 
    self.send_changeTransactionStatus(transactionId, status, description)
1163 
    return self.recv_changeTransactionStatus()
1164 
 
1165 
  def send_changeTransactionStatus(self, transactionId, status, description):
1166 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1167 
    args = changeTransactionStatus_args()
1168 
    args.transactionId = transactionId
1169 
    args.status = status
1170 
    args.description = description
1171 
    args.write(self._oprot)
1172 
    self._oprot.writeMessageEnd()
1173 
    self._oprot.trans.flush()
1174 
 
1175 
  def recv_changeTransactionStatus(self, ):
1176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1177 
    if mtype == TMessageType.EXCEPTION:
1178 
      x = TApplicationException()
1179 
      x.read(self._iprot)
1180 
      self._iprot.readMessageEnd()
1181 
      raise x
1182 
    result = changeTransactionStatus_result()
1183 
    result.read(self._iprot)
1184 
    self._iprot.readMessageEnd()
3431 rajveer 1185 
    if result.success is not None:
94 ashish 1186 
      return result.success
3431 rajveer 1187 
    if result.ex is not None:
94 ashish 1188 
      raise result.ex
1189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1190 
 
1398 varun.gupt 1191 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1192 
    """
1193 
    Parameters:
1194 
     - transactionId
1195 
    """
1398 varun.gupt 1196 
    self.send_enqueueTransactionInfoEmail(transactionId)
1197 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1198 
 
1398 varun.gupt 1199 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1200 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1201 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1202 
    args.transactionId = transactionId
1203 
    args.write(self._oprot)
1204 
    self._oprot.writeMessageEnd()
1205 
    self._oprot.trans.flush()
1206 
 
1398 varun.gupt 1207 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 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
1398 varun.gupt 1214 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1215 
    result.read(self._iprot)
1216 
    self._iprot.readMessageEnd()
3431 rajveer 1217 
    if result.success is not None:
1382 varun.gupt 1218 
      return result.success
3431 rajveer 1219 
    if result.ex is not None:
1382 varun.gupt 1220 
      raise result.ex
1398 varun.gupt 1221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1222 
 
483 rajveer 1223 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1224 
    """
1225 
    Parameters:
483 rajveer 1226 
     - status
1227 
     - from_date
1228 
     - to_date
1229 
     - warehouse_id
94 ashish 1230 
    """
483 rajveer 1231 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1232 
    return self.recv_getAllOrders()
94 ashish 1233 
 
483 rajveer 1234 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1235 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1236 
    args = getAllOrders_args()
1237 
    args.status = status
1238 
    args.from_date = from_date
1239 
    args.to_date = to_date
1240 
    args.warehouse_id = warehouse_id
94 ashish 1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
483 rajveer 1245 
  def recv_getAllOrders(self, ):
94 ashish 1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
483 rajveer 1252 
    result = getAllOrders_result()
94 ashish 1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
3431 rajveer 1255 
    if result.success is not None:
94 ashish 1256 
      return result.success
3431 rajveer 1257 
    if result.ex is not None:
94 ashish 1258 
      raise result.ex
483 rajveer 1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1260 
 
4133 chandransh 1261 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1262 
    """
1263 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1264 
    Pass the status as null and the limit as 0 to ignore them.
1265 
 
1266 
    Parameters:
1267 
     - statuses
1268 
     - offset
1269 
     - limit
1270 
     - warehouse_id
1271 
    """
1272 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1273 
    return self.recv_getOrdersInBatch()
1274 
 
1275 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1276 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1277 
    args = getOrdersInBatch_args()
1278 
    args.statuses = statuses
1279 
    args.offset = offset
1280 
    args.limit = limit
1281 
    args.warehouse_id = warehouse_id
1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
1286 
  def recv_getOrdersInBatch(self, ):
1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
1293 
    result = getOrdersInBatch_result()
1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
1296 
    if result.success is not None:
1297 
      return result.success
1298 
    if result.ex is not None:
1299 
      raise result.ex
1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1301 
 
1302 
  def getOrderCount(self, statuses, warehouseId):
1303 
    """
1304 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1305 
 
1306 
    Parameters:
1307 
     - statuses
1308 
     - warehouseId
1309 
    """
1310 
    self.send_getOrderCount(statuses, warehouseId)
1311 
    return self.recv_getOrderCount()
1312 
 
1313 
  def send_getOrderCount(self, statuses, warehouseId):
1314 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1315 
    args = getOrderCount_args()
1316 
    args.statuses = statuses
1317 
    args.warehouseId = warehouseId
1318 
    args.write(self._oprot)
1319 
    self._oprot.writeMessageEnd()
1320 
    self._oprot.trans.flush()
1321 
 
1322 
  def recv_getOrderCount(self, ):
1323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1324 
    if mtype == TMessageType.EXCEPTION:
1325 
      x = TApplicationException()
1326 
      x.read(self._iprot)
1327 
      self._iprot.readMessageEnd()
1328 
      raise x
1329 
    result = getOrderCount_result()
1330 
    result.read(self._iprot)
1331 
    self._iprot.readMessageEnd()
1332 
    if result.success is not None:
1333 
      return result.success
1334 
    if result.ex is not None:
1335 
      raise result.ex
1336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1337 
 
999 varun.gupt 1338 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1339 
    """
1132 chandransh 1340 
    Returns orders within a range of their billing dates
3431 rajveer 1341 
 
999 varun.gupt 1342 
    Parameters:
1343 
     - status
1344 
     - start_billing_date
1345 
     - end_billing_date
1346 
     - warehouse_id
1347 
    """
1348 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1349 
    return self.recv_getOrdersByBillingDate()
1350 
 
1351 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1352 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1353 
    args = getOrdersByBillingDate_args()
1354 
    args.status = status
1355 
    args.start_billing_date = start_billing_date
1356 
    args.end_billing_date = end_billing_date
1357 
    args.warehouse_id = warehouse_id
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_getOrdersByBillingDate(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = getOrdersByBillingDate_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
3431 rajveer 1372 
    if result.success is not None:
999 varun.gupt 1373 
      return result.success
3431 rajveer 1374 
    if result.ex is not None:
999 varun.gupt 1375 
      raise result.ex
1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1377 
 
3451 chandransh 1378 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1379 
    """
1380 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1381 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1382 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1383 
 
3427 chandransh 1384 
    Parameters:
1385 
     - fromShippingDate
1386 
     - toShippingDate
1387 
     - providerId
1388 
     - warehouseId
3451 chandransh 1389 
     - cod
3427 chandransh 1390 
    """
3451 chandransh 1391 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1392 
    return self.recv_getOrdersByShippingDate()
1393 
 
3451 chandransh 1394 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1395 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1396 
    args = getOrdersByShippingDate_args()
1397 
    args.fromShippingDate = fromShippingDate
1398 
    args.toShippingDate = toShippingDate
1399 
    args.providerId = providerId
1400 
    args.warehouseId = warehouseId
3451 chandransh 1401 
    args.cod = cod
3427 chandransh 1402 
    args.write(self._oprot)
1403 
    self._oprot.writeMessageEnd()
1404 
    self._oprot.trans.flush()
1405 
 
1406 
  def recv_getOrdersByShippingDate(self, ):
1407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1408 
    if mtype == TMessageType.EXCEPTION:
1409 
      x = TApplicationException()
1410 
      x.read(self._iprot)
1411 
      self._iprot.readMessageEnd()
1412 
      raise x
1413 
    result = getOrdersByShippingDate_result()
1414 
    result.read(self._iprot)
1415 
    self._iprot.readMessageEnd()
3431 rajveer 1416 
    if result.success is not None:
3427 chandransh 1417 
      return result.success
3431 rajveer 1418 
    if result.ex is not None:
3427 chandransh 1419 
      raise result.ex
1420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1421 
 
1382 varun.gupt 1422 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1423 
    """
1424 
    Returns order ids for orders which can be returned
3431 rajveer 1425 
 
1382 varun.gupt 1426 
    Parameters:
1427 
     - customer_id
1428 
     - limit
1429 
    """
1430 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1431 
    return self.recv_getReturnableOrdersForCustomer()
1432 
 
1433 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1434 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1435 
    args = getReturnableOrdersForCustomer_args()
1436 
    args.customer_id = customer_id
1437 
    args.limit = limit
1438 
    args.write(self._oprot)
1439 
    self._oprot.writeMessageEnd()
1440 
    self._oprot.trans.flush()
1441 
 
1442 
  def recv_getReturnableOrdersForCustomer(self, ):
1443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1444 
    if mtype == TMessageType.EXCEPTION:
1445 
      x = TApplicationException()
1446 
      x.read(self._iprot)
1447 
      self._iprot.readMessageEnd()
1448 
      raise x
1449 
    result = getReturnableOrdersForCustomer_result()
1450 
    result.read(self._iprot)
1451 
    self._iprot.readMessageEnd()
3431 rajveer 1452 
    if result.success is not None:
1382 varun.gupt 1453 
      return result.success
3431 rajveer 1454 
    if result.ex is not None:
1382 varun.gupt 1455 
      raise result.ex
1456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1457 
 
1458 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1459 
    """
1460 
    Returns order ids for orders which can be cancelled
3431 rajveer 1461 
 
1382 varun.gupt 1462 
    Parameters:
1463 
     - customer_id
1464 
     - limit
1465 
    """
1466 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1467 
    return self.recv_getCancellableOrdersForCustomer()
1468 
 
1469 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1470 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1471 
    args = getCancellableOrdersForCustomer_args()
1472 
    args.customer_id = customer_id
1473 
    args.limit = limit
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getCancellableOrdersForCustomer(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getCancellableOrdersForCustomer_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
3431 rajveer 1488 
    if result.success is not None:
1382 varun.gupt 1489 
      return result.success
3431 rajveer 1490 
    if result.ex is not None:
1382 varun.gupt 1491 
      raise result.ex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1493 
 
483 rajveer 1494 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1495 
    """
1496 
    Parameters:
483 rajveer 1497 
     - orderId
1498 
     - status
1499 
     - description
94 ashish 1500 
    """
483 rajveer 1501 
    self.send_changeOrderStatus(orderId, status, description)
1502 
    return self.recv_changeOrderStatus()
94 ashish 1503 
 
483 rajveer 1504 
  def send_changeOrderStatus(self, orderId, status, description):
1505 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1506 
    args = changeOrderStatus_args()
1507 
    args.orderId = orderId
1508 
    args.status = status
1509 
    args.description = description
94 ashish 1510 
    args.write(self._oprot)
1511 
    self._oprot.writeMessageEnd()
1512 
    self._oprot.trans.flush()
1513 
 
483 rajveer 1514 
  def recv_changeOrderStatus(self, ):
94 ashish 1515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1516 
    if mtype == TMessageType.EXCEPTION:
1517 
      x = TApplicationException()
1518 
      x.read(self._iprot)
1519 
      self._iprot.readMessageEnd()
1520 
      raise x
483 rajveer 1521 
    result = changeOrderStatus_result()
94 ashish 1522 
    result.read(self._iprot)
1523 
    self._iprot.readMessageEnd()
3431 rajveer 1524 
    if result.success is not None:
94 ashish 1525 
      return result.success
3431 rajveer 1526 
    if result.ex is not None:
94 ashish 1527 
      raise result.ex
483 rajveer 1528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1529 
 
1528 ankur.sing 1530 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1531 
    """
1528 ankur.sing 1532 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1533 
    only user who owns the transaction can view its order details.
3431 rajveer 1534 
 
94 ashish 1535 
    Parameters:
1536 
     - transactionId
1528 ankur.sing 1537 
     - customerId
94 ashish 1538 
    """
1528 ankur.sing 1539 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1540 
    return self.recv_getOrdersForTransaction()
94 ashish 1541 
 
1528 ankur.sing 1542 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1543 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1544 
    args = getOrdersForTransaction_args()
94 ashish 1545 
    args.transactionId = transactionId
1528 ankur.sing 1546 
    args.customerId = customerId
94 ashish 1547 
    args.write(self._oprot)
1548 
    self._oprot.writeMessageEnd()
1549 
    self._oprot.trans.flush()
1550 
 
483 rajveer 1551 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1553 
    if mtype == TMessageType.EXCEPTION:
1554 
      x = TApplicationException()
1555 
      x.read(self._iprot)
1556 
      self._iprot.readMessageEnd()
1557 
      raise x
483 rajveer 1558 
    result = getOrdersForTransaction_result()
94 ashish 1559 
    result.read(self._iprot)
1560 
    self._iprot.readMessageEnd()
3431 rajveer 1561 
    if result.success is not None:
94 ashish 1562 
      return result.success
3431 rajveer 1563 
    if result.ex is not None:
94 ashish 1564 
      raise result.ex
483 rajveer 1565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1566 
 
3014 chandransh 1567 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1568 
    """
3014 chandransh 1569 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1570 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1571 
 
94 ashish 1572 
    Parameters:
483 rajveer 1573 
     - customerId
1574 
     - from_date
1575 
     - to_date
3014 chandransh 1576 
     - statuses
94 ashish 1577 
    """
3014 chandransh 1578 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1579 
    return self.recv_getOrdersForCustomer()
94 ashish 1580 
 
3014 chandransh 1581 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1582 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1583 
    args = getOrdersForCustomer_args()
1584 
    args.customerId = customerId
1585 
    args.from_date = from_date
1586 
    args.to_date = to_date
3014 chandransh 1587 
    args.statuses = statuses
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
483 rajveer 1592 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
483 rajveer 1599 
    result = getOrdersForCustomer_result()
94 ashish 1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
483 rajveer 1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1607 
 
483 rajveer 1608 
  def createOrder(self, order):
94 ashish 1609 
    """
1610 
    Parameters:
483 rajveer 1611 
     - order
94 ashish 1612 
    """
483 rajveer 1613 
    self.send_createOrder(order)
1614 
    return self.recv_createOrder()
94 ashish 1615 
 
483 rajveer 1616 
  def send_createOrder(self, order):
1617 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1618 
    args = createOrder_args()
1619 
    args.order = order
94 ashish 1620 
    args.write(self._oprot)
1621 
    self._oprot.writeMessageEnd()
1622 
    self._oprot.trans.flush()
1623 
 
483 rajveer 1624 
  def recv_createOrder(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 = createOrder_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, "createOrder failed: unknown result");
94 ashish 1639 
 
483 rajveer 1640 
  def getOrder(self, id):
94 ashish 1641 
    """
1642 
    Parameters:
483 rajveer 1643 
     - id
94 ashish 1644 
    """
483 rajveer 1645 
    self.send_getOrder(id)
1646 
    return self.recv_getOrder()
94 ashish 1647 
 
483 rajveer 1648 
  def send_getOrder(self, id):
1649 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1650 
    args = getOrder_args()
1651 
    args.id = id
94 ashish 1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
483 rajveer 1656 
  def recv_getOrder(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 = getOrder_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, "getOrder failed: unknown result");
94 ashish 1671 
 
483 rajveer 1672 
  def getLineItemsForOrder(self, orderId):
94 ashish 1673 
    """
1674 
    Parameters:
483 rajveer 1675 
     - orderId
94 ashish 1676 
    """
483 rajveer 1677 
    self.send_getLineItemsForOrder(orderId)
1678 
    return self.recv_getLineItemsForOrder()
94 ashish 1679 
 
483 rajveer 1680 
  def send_getLineItemsForOrder(self, orderId):
1681 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1682 
    args = getLineItemsForOrder_args()
1683 
    args.orderId = orderId
94 ashish 1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
483 rajveer 1688 
  def recv_getLineItemsForOrder(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 = getLineItemsForOrder_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, "getLineItemsForOrder failed: unknown result");
94 ashish 1703 
 
1528 ankur.sing 1704 
  def getOrderForCustomer(self, orderId, customerId):
1705 
    """
1706 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1707 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1708 
 
1528 ankur.sing 1709 
    Parameters:
1710 
     - orderId
1711 
     - customerId
1712 
    """
1713 
    self.send_getOrderForCustomer(orderId, customerId)
1714 
    return self.recv_getOrderForCustomer()
1715 
 
1716 
  def send_getOrderForCustomer(self, orderId, customerId):
1717 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1718 
    args = getOrderForCustomer_args()
1719 
    args.orderId = orderId
1720 
    args.customerId = customerId
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getOrderForCustomer(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getOrderForCustomer_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
3431 rajveer 1735 
    if result.success is not None:
1528 ankur.sing 1736 
      return result.success
3431 rajveer 1737 
    if result.ex is not None:
1528 ankur.sing 1738 
      raise result.ex
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1740 
 
4444 rajveer 1741 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1742 
    """
1743 
    Parameters:
4394 rajveer 1744 
     - type
4444 rajveer 1745 
     - warehouseId
4394 rajveer 1746 
     - status
1747 
     - timestamp
3064 chandransh 1748 
    """
4444 rajveer 1749 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1750 
    return self.recv_getAlerts()
1751 
 
4444 rajveer 1752 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1753 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1754 
    args = getAlerts_args()
4394 rajveer 1755 
    args.type = type
4444 rajveer 1756 
    args.warehouseId = warehouseId
4394 rajveer 1757 
    args.status = status
1758 
    args.timestamp = timestamp
3064 chandransh 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getAlerts(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getAlerts_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
3431 rajveer 1773 
    if result.success is not None:
3064 chandransh 1774 
      return result.success
1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1776 
 
4444 rajveer 1777 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1778 
    """
1779 
    Parameters:
1780 
     - type
4444 rajveer 1781 
     - warehouseId
4394 rajveer 1782 
     - description
3064 chandransh 1783 
    """
4444 rajveer 1784 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1785 
    self.recv_addAlert()
3064 chandransh 1786 
 
4444 rajveer 1787 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1788 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1789 
    args = addAlert_args()
3064 chandransh 1790 
    args.type = type
4444 rajveer 1791 
    args.warehouseId = warehouseId
4394 rajveer 1792 
    args.description = description
3064 chandransh 1793 
    args.write(self._oprot)
1794 
    self._oprot.writeMessageEnd()
1795 
    self._oprot.trans.flush()
1796 
 
4394 rajveer 1797 
  def recv_addAlert(self, ):
3064 chandransh 1798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1799 
    if mtype == TMessageType.EXCEPTION:
1800 
      x = TApplicationException()
1801 
      x.read(self._iprot)
1802 
      self._iprot.readMessageEnd()
1803 
      raise x
4394 rajveer 1804 
    result = addAlert_result()
3064 chandransh 1805 
    result.read(self._iprot)
1806 
    self._iprot.readMessageEnd()
1807 
    return
1808 
 
4444 rajveer 1809 
  def markAlertsAsSeen(self, warehouseId):
1810 
    """
1811 
    Parameters:
1812 
     - warehouseId
1813 
    """
1814 
    self.send_markAlertsAsSeen(warehouseId)
1815 
    self.recv_markAlertsAsSeen()
1816 
 
1817 
  def send_markAlertsAsSeen(self, warehouseId):
1818 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1819 
    args = markAlertsAsSeen_args()
1820 
    args.warehouseId = warehouseId
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_markAlertsAsSeen(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = markAlertsAsSeen_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
1835 
    return
1836 
 
3064 chandransh 1837 
  def getValidOrderCount(self, ):
1838 
    """
1839 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1840 
    """
1841 
    self.send_getValidOrderCount()
1842 
    return self.recv_getValidOrderCount()
1843 
 
1844 
  def send_getValidOrderCount(self, ):
1845 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1846 
    args = getValidOrderCount_args()
1847 
    args.write(self._oprot)
1848 
    self._oprot.writeMessageEnd()
1849 
    self._oprot.trans.flush()
1850 
 
1851 
  def recv_getValidOrderCount(self, ):
1852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1853 
    if mtype == TMessageType.EXCEPTION:
1854 
      x = TApplicationException()
1855 
      x.read(self._iprot)
1856 
      self._iprot.readMessageEnd()
1857 
      raise x
1858 
    result = getValidOrderCount_result()
1859 
    result.read(self._iprot)
1860 
    self._iprot.readMessageEnd()
3431 rajveer 1861 
    if result.success is not None:
3064 chandransh 1862 
      return result.success
1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1864 
 
1865 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1866 
    """
1867 
    Returns the number of distinct customers who have done successful transactions
1868 
    """
1869 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1870 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1871 
 
1872 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1873 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1874 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
3064 chandransh 1890 
      return result.success
1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1892 
 
1893 
  def getValidOrdersAmountRange(self, ):
1894 
    """
1895 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1896 
    List contains two values, first minimum amount and second maximum amount.
1897 
    """
1898 
    self.send_getValidOrdersAmountRange()
1899 
    return self.recv_getValidOrdersAmountRange()
1900 
 
1901 
  def send_getValidOrdersAmountRange(self, ):
1902 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1903 
    args = getValidOrdersAmountRange_args()
1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
1908 
  def recv_getValidOrdersAmountRange(self, ):
1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
1915 
    result = getValidOrdersAmountRange_result()
1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
3431 rajveer 1918 
    if result.success is not None:
3064 chandransh 1919 
      return result.success
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1921 
 
1922 
  def getValidOrders(self, limit):
1923 
    """
1924 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1925 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1926 
 
3064 chandransh 1927 
    Parameters:
1928 
     - limit
1929 
    """
1930 
    self.send_getValidOrders(limit)
1931 
    return self.recv_getValidOrders()
1932 
 
1933 
  def send_getValidOrders(self, limit):
1934 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1935 
    args = getValidOrders_args()
1936 
    args.limit = limit
1937 
    args.write(self._oprot)
1938 
    self._oprot.writeMessageEnd()
1939 
    self._oprot.trans.flush()
1940 
 
1941 
  def recv_getValidOrders(self, ):
1942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1943 
    if mtype == TMessageType.EXCEPTION:
1944 
      x = TApplicationException()
1945 
      x.read(self._iprot)
1946 
      self._iprot.readMessageEnd()
1947 
      raise x
1948 
    result = getValidOrders_result()
1949 
    result.read(self._iprot)
1950 
    self._iprot.readMessageEnd()
3431 rajveer 1951 
    if result.success is not None:
3064 chandransh 1952 
      return result.success
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1954 
 
1220 chandransh 1955 
  def batchOrders(self, warehouseId):
1956 
    """
1957 
    Create a batch of all the pending orders for the given warehouse.
1958 
    The returned list is orderd by created_timestamp.
1959 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1960 
 
1220 chandransh 1961 
    Parameters:
1962 
     - warehouseId
1963 
    """
1964 
    self.send_batchOrders(warehouseId)
1965 
    return self.recv_batchOrders()
1966 
 
1967 
  def send_batchOrders(self, warehouseId):
1968 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1969 
    args = batchOrders_args()
1970 
    args.warehouseId = warehouseId
1971 
    args.write(self._oprot)
1972 
    self._oprot.writeMessageEnd()
1973 
    self._oprot.trans.flush()
1974 
 
1975 
  def recv_batchOrders(self, ):
1976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1977 
    if mtype == TMessageType.EXCEPTION:
1978 
      x = TApplicationException()
1979 
      x.read(self._iprot)
1980 
      self._iprot.readMessageEnd()
1981 
      raise x
1982 
    result = batchOrders_result()
1983 
    result.read(self._iprot)
1984 
    self._iprot.readMessageEnd()
3431 rajveer 1985 
    if result.success is not None:
1220 chandransh 1986 
      return result.success
3431 rajveer 1987 
    if result.ex is not None:
1220 chandransh 1988 
      raise result.ex
1989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1990 
 
1208 chandransh 1991 
  def markOrderAsOutOfStock(self, orderId):
1992 
    """
1993 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1994 
 
1208 chandransh 1995 
    Parameters:
1996 
     - orderId
1997 
    """
1998 
    self.send_markOrderAsOutOfStock(orderId)
1999 
    return self.recv_markOrderAsOutOfStock()
2000 
 
2001 
  def send_markOrderAsOutOfStock(self, orderId):
2002 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2003 
    args = markOrderAsOutOfStock_args()
2004 
    args.orderId = orderId
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_markOrderAsOutOfStock(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = markOrderAsOutOfStock_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
1208 chandransh 2020 
      return result.success
3431 rajveer 2021 
    if result.ex is not None:
1208 chandransh 2022 
      raise result.ex
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2024 
 
3064 chandransh 2025 
  def verifyOrder(self, orderId):
759 chandransh 2026 
    """
3064 chandransh 2027 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2028 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2029 
    used for all other orders as well.
2030 
    Throws an exception if no such order exists.
3431 rajveer 2031 
 
759 chandransh 2032 
    Parameters:
3064 chandransh 2033 
     - orderId
759 chandransh 2034 
    """
3064 chandransh 2035 
    self.send_verifyOrder(orderId)
2036 
    return self.recv_verifyOrder()
759 chandransh 2037 
 
3064 chandransh 2038 
  def send_verifyOrder(self, orderId):
2039 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2040 
    args = verifyOrder_args()
2041 
    args.orderId = orderId
759 chandransh 2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
3064 chandransh 2046 
  def recv_verifyOrder(self, ):
759 chandransh 2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
3064 chandransh 2053 
    result = verifyOrder_result()
759 chandransh 2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
3431 rajveer 2056 
    if result.success is not None:
759 chandransh 2057 
      return result.success
3431 rajveer 2058 
    if result.ex is not None:
759 chandransh 2059 
      raise result.ex
3064 chandransh 2060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2061 
 
3064 chandransh 2062 
  def acceptOrder(self, orderId):
1113 chandransh 2063 
    """
3064 chandransh 2064 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2065 
    given order is not a COD order, it also captures the payment if the same has
2066 
    not been captured.
2067 
    Throws an exception if no such order exists.
3431 rajveer 2068 
 
1113 chandransh 2069 
    Parameters:
3064 chandransh 2070 
     - orderId
1113 chandransh 2071 
    """
3064 chandransh 2072 
    self.send_acceptOrder(orderId)
2073 
    return self.recv_acceptOrder()
1113 chandransh 2074 
 
3064 chandransh 2075 
  def send_acceptOrder(self, orderId):
2076 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2077 
    args = acceptOrder_args()
2078 
    args.orderId = orderId
1113 chandransh 2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
3064 chandransh 2083 
  def recv_acceptOrder(self, ):
1113 chandransh 2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
3064 chandransh 2090 
    result = acceptOrder_result()
1113 chandransh 2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
3431 rajveer 2093 
    if result.success is not None:
1113 chandransh 2094 
      return result.success
3431 rajveer 2095 
    if result.ex is not None:
1113 chandransh 2096 
      raise result.ex
3064 chandransh 2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2098 
 
4658 mandeep.dh 2099 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2100 
    """
3064 chandransh 2101 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2102 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2103 
    the IMEI no. if a -1 is supplied.
2104 
    Also, it generates an invoice number for the order, marks the order as
2105 
    BILLED and sets the billing timestamp.
2106 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2107 
 
1135 chandransh 2108 
    Parameters:
3064 chandransh 2109 
     - orderId
2110 
     - invoice_number
4658 mandeep.dh 2111 
     - serialNumber
4283 anupam.sin 2112 
     - itemNumber
3064 chandransh 2113 
     - billed_by
4264 rajveer 2114 
     - jacketNumber
4283 anupam.sin 2115 
     - billingType
2116 
     - vendorId
1135 chandransh 2117 
    """
4658 mandeep.dh 2118 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2119 
    return self.recv_addBillingDetails()
1135 chandransh 2120 
 
4658 mandeep.dh 2121 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2122 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2123 
    args = addBillingDetails_args()
2124 
    args.orderId = orderId
2125 
    args.invoice_number = invoice_number
4658 mandeep.dh 2126 
    args.serialNumber = serialNumber
4283 anupam.sin 2127 
    args.itemNumber = itemNumber
3064 chandransh 2128 
    args.billed_by = billed_by
4264 rajveer 2129 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2130 
    args.billingType = billingType
2131 
    args.vendorId = vendorId
1135 chandransh 2132 
    args.write(self._oprot)
2133 
    self._oprot.writeMessageEnd()
2134 
    self._oprot.trans.flush()
2135 
 
3064 chandransh 2136 
  def recv_addBillingDetails(self, ):
1135 chandransh 2137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2138 
    if mtype == TMessageType.EXCEPTION:
2139 
      x = TApplicationException()
2140 
      x.read(self._iprot)
2141 
      self._iprot.readMessageEnd()
2142 
      raise x
3064 chandransh 2143 
    result = addBillingDetails_result()
1135 chandransh 2144 
    result.read(self._iprot)
2145 
    self._iprot.readMessageEnd()
3431 rajveer 2146 
    if result.success is not None:
3064 chandransh 2147 
      return result.success
3431 rajveer 2148 
    if result.ex is not None:
1135 chandransh 2149 
      raise result.ex
3064 chandransh 2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2151 
 
4579 rajveer 2152 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2153 
    """
2154 
    Add the invoice number to the order.
2155 
 
2156 
    Parameters:
2157 
     - orderId
2158 
     - invoiceNumber
2159 
    """
2160 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2161 
    self.recv_addInvoiceNumber()
2162 
 
2163 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2164 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2165 
    args = addInvoiceNumber_args()
2166 
    args.orderId = orderId
2167 
    args.invoiceNumber = invoiceNumber
2168 
    args.write(self._oprot)
2169 
    self._oprot.writeMessageEnd()
2170 
    self._oprot.trans.flush()
2171 
 
2172 
  def recv_addInvoiceNumber(self, ):
2173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2174 
    if mtype == TMessageType.EXCEPTION:
2175 
      x = TApplicationException()
2176 
      x.read(self._iprot)
2177 
      self._iprot.readMessageEnd()
2178 
      raise x
2179 
    result = addInvoiceNumber_result()
2180 
    result.read(self._iprot)
2181 
    self._iprot.readMessageEnd()
2182 
    if result.ex is not None:
2183 
      raise result.ex
2184 
    return
2185 
 
3064 chandransh 2186 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2187 
    """
3064 chandransh 2188 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2189 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2190 
 
1408 ankur.sing 2191 
    Parameters:
3064 chandransh 2192 
     - warehouseId
1408 ankur.sing 2193 
     - providerId
3064 chandransh 2194 
     - cod
1408 ankur.sing 2195 
    """
3064 chandransh 2196 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2197 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2198 
 
3064 chandransh 2199 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2200 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2201 
    args = markOrdersAsManifested_args()
2202 
    args.warehouseId = warehouseId
1408 ankur.sing 2203 
    args.providerId = providerId
3064 chandransh 2204 
    args.cod = cod
1408 ankur.sing 2205 
    args.write(self._oprot)
2206 
    self._oprot.writeMessageEnd()
2207 
    self._oprot.trans.flush()
2208 
 
3064 chandransh 2209 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2211 
    if mtype == TMessageType.EXCEPTION:
2212 
      x = TApplicationException()
2213 
      x.read(self._iprot)
2214 
      self._iprot.readMessageEnd()
2215 
      raise x
3064 chandransh 2216 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2217 
    result.read(self._iprot)
2218 
    self._iprot.readMessageEnd()
3431 rajveer 2219 
    if result.success is not None:
1408 ankur.sing 2220 
      return result.success
3431 rajveer 2221 
    if result.ex is not None:
3064 chandransh 2222 
      raise result.ex
2223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2224 
 
4410 rajveer 2225 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2226 
    """
2227 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2228 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2229 
 
2230 
    Parameters:
2231 
     - warehouseId
2232 
     - providerId
2233 
     - cod
2234 
    """
2235 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2236 
    return self.recv_markOrdersAsShippedFromWarehouse()
2237 
 
2238 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2239 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2240 
    args = markOrdersAsShippedFromWarehouse_args()
2241 
    args.warehouseId = warehouseId
2242 
    args.providerId = providerId
2243 
    args.cod = cod
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = markOrdersAsShippedFromWarehouse_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
2258 
    if result.success is not None:
2259 
      return result.success
2260 
    if result.ex is not None:
2261 
      raise result.ex
2262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2263 
 
3064 chandransh 2264 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2265 
    """
3064 chandransh 2266 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2267 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2268 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2269 
 
94 ashish 2270 
    Parameters:
3064 chandransh 2271 
     - providerId
2272 
     - pickupDetails
304 ashish 2273 
    """
3064 chandransh 2274 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2275 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2276 
 
3064 chandransh 2277 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2278 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2279 
    args = markOrdersAsPickedUp_args()
2280 
    args.providerId = providerId
2281 
    args.pickupDetails = pickupDetails
304 ashish 2282 
    args.write(self._oprot)
2283 
    self._oprot.writeMessageEnd()
2284 
    self._oprot.trans.flush()
2285 
 
3064 chandransh 2286 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2288 
    if mtype == TMessageType.EXCEPTION:
2289 
      x = TApplicationException()
2290 
      x.read(self._iprot)
2291 
      self._iprot.readMessageEnd()
2292 
      raise x
3064 chandransh 2293 
    result = markOrdersAsPickedUp_result()
304 ashish 2294 
    result.read(self._iprot)
2295 
    self._iprot.readMessageEnd()
3431 rajveer 2296 
    if result.success is not None:
304 ashish 2297 
      return result.success
3431 rajveer 2298 
    if result.ex is not None:
3064 chandransh 2299 
      raise result.ex
2300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2301 
 
3064 chandransh 2302 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2303 
    """
3064 chandransh 2304 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2305 
    the name of the receiver.
2306 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2307 
 
304 ashish 2308 
    Parameters:
3064 chandransh 2309 
     - providerId
2310 
     - deliveredOrders
304 ashish 2311 
    """
3064 chandransh 2312 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2313 
    self.recv_markOrdersAsDelivered()
304 ashish 2314 
 
3064 chandransh 2315 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2316 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2317 
    args = markOrdersAsDelivered_args()
2318 
    args.providerId = providerId
2319 
    args.deliveredOrders = deliveredOrders
304 ashish 2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
3064 chandransh 2324 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
3064 chandransh 2331 
    result = markOrdersAsDelivered_result()
304 ashish 2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
3431 rajveer 2334 
    if result.ex is not None:
3064 chandransh 2335 
      raise result.ex
304 ashish 2336 
    return
2337 
 
3064 chandransh 2338 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2339 
    """
3064 chandransh 2340 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2341 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2342 
 
3064 chandransh 2343 
    Parameters:
2344 
     - providerId
2345 
     - returnedOrders
1596 ankur.sing 2346 
    """
3064 chandransh 2347 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2348 
    self.recv_markOrdersAsFailed()
304 ashish 2349 
 
3064 chandransh 2350 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2351 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2352 
    args = markOrdersAsFailed_args()
2353 
    args.providerId = providerId
2354 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2355 
    args.write(self._oprot)
2356 
    self._oprot.writeMessageEnd()
2357 
    self._oprot.trans.flush()
2358 
 
3064 chandransh 2359 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2361 
    if mtype == TMessageType.EXCEPTION:
2362 
      x = TApplicationException()
2363 
      x.read(self._iprot)
2364 
      self._iprot.readMessageEnd()
2365 
      raise x
3064 chandransh 2366 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2367 
    result.read(self._iprot)
2368 
    self._iprot.readMessageEnd()
3431 rajveer 2369 
    if result.ex is not None:
3064 chandransh 2370 
      raise result.ex
2371 
    return
1596 ankur.sing 2372 
 
3064 chandransh 2373 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2374 
    """
3064 chandransh 2375 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2376 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2377 
 
3064 chandransh 2378 
    Parameters:
2379 
     - providerId
2380 
     - undeliveredOrders
1627 ankur.sing 2381 
    """
3064 chandransh 2382 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2383 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2384 
 
3064 chandransh 2385 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2386 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2387 
    args = updateNonDeliveryReason_args()
2388 
    args.providerId = providerId
2389 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2390 
    args.write(self._oprot)
2391 
    self._oprot.writeMessageEnd()
2392 
    self._oprot.trans.flush()
2393 
 
3064 chandransh 2394 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2396 
    if mtype == TMessageType.EXCEPTION:
2397 
      x = TApplicationException()
2398 
      x.read(self._iprot)
2399 
      self._iprot.readMessageEnd()
2400 
      raise x
3064 chandransh 2401 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2402 
    result.read(self._iprot)
2403 
    self._iprot.readMessageEnd()
4581 phani.kuma 2404 
    if result.success is not None:
2405 
      return result.success
3431 rajveer 2406 
    if result.ex is not None:
3064 chandransh 2407 
      raise result.ex
4581 phani.kuma 2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2409 
 
3064 chandransh 2410 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2411 
    """
3064 chandransh 2412 
    Returns the list of orders whose delivery time has passed but have not been
2413 
    delivered yet for the given provider and warehouse. To get a complete list of
2414 
    undelivered orders, pass them as -1.
2415 
    Returns an empty list if no such orders exist.
3431 rajveer 2416 
 
1886 ankur.sing 2417 
    Parameters:
3064 chandransh 2418 
     - providerId
2419 
     - warehouseId
1886 ankur.sing 2420 
    """
3064 chandransh 2421 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2422 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2423 
 
3064 chandransh 2424 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2425 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2426 
    args = getUndeliveredOrders_args()
2427 
    args.providerId = providerId
2428 
    args.warehouseId = warehouseId
1886 ankur.sing 2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
3064 chandransh 2433 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
3064 chandransh 2440 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
3431 rajveer 2443 
    if result.success is not None:
1886 ankur.sing 2444 
      return result.success
3064 chandransh 2445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2446 
 
2536 chandransh 2447 
  def toggleDOAFlag(self, orderId):
2448 
    """
2449 
    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.
2450 
    Returns the final flag status.
2451 
    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 2452 
 
2536 chandransh 2453 
    Parameters:
2454 
     - orderId
2455 
    """
2456 
    self.send_toggleDOAFlag(orderId)
2457 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2458 
 
2536 chandransh 2459 
  def send_toggleDOAFlag(self, orderId):
2460 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2461 
    args = toggleDOAFlag_args()
2462 
    args.orderId = orderId
2463 
    args.write(self._oprot)
2464 
    self._oprot.writeMessageEnd()
2465 
    self._oprot.trans.flush()
2466 
 
2467 
  def recv_toggleDOAFlag(self, ):
2468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2469 
    if mtype == TMessageType.EXCEPTION:
2470 
      x = TApplicationException()
2471 
      x.read(self._iprot)
2472 
      self._iprot.readMessageEnd()
2473 
      raise x
2474 
    result = toggleDOAFlag_result()
2475 
    result.read(self._iprot)
2476 
    self._iprot.readMessageEnd()
3431 rajveer 2477 
    if result.success is not None:
2536 chandransh 2478 
      return result.success
3431 rajveer 2479 
    if result.ex is not None:
2536 chandransh 2480 
      raise result.ex
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2482 
 
4712 rajveer 2483 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2484 
    """
2485 
    Parameters:
2486 
     - orderId
2487 
     - deliveryTimestamp
2488 
     - receiver
2489 
    """
2490 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2491 
    self.recv_markOrderAsDelivered()
2492 
 
2493 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2494 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2495 
    args = markOrderAsDelivered_args()
2496 
    args.orderId = orderId
2497 
    args.deliveryTimestamp = deliveryTimestamp
2498 
    args.receiver = receiver
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_markOrderAsDelivered(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 = markOrderAsDelivered_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
2513 
    if result.ex is not None:
2514 
      raise result.ex
2515 
    return
2516 
 
4454 rajveer 2517 
  def markOrderDoaRequestReceived(self, orderId):
2518 
    """
2519 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2520 
 
2521 
    Parameters:
2522 
     - orderId
2523 
    """
2524 
    self.send_markOrderDoaRequestReceived(orderId)
2525 
    return self.recv_markOrderDoaRequestReceived()
2526 
 
2527 
  def send_markOrderDoaRequestReceived(self, orderId):
2528 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2529 
    args = markOrderDoaRequestReceived_args()
2530 
    args.orderId = orderId
2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2535 
  def recv_markOrderDoaRequestReceived(self, ):
2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2542 
    result = markOrderDoaRequestReceived_result()
2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
2545 
    if result.success is not None:
2546 
      return result.success
2547 
    if result.ex is not None:
2548 
      raise result.ex
2549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2550 
 
2551 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2552 
    """
2553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2554 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2555 
 
2556 
    Parameters:
2557 
     - orderId
2558 
     - isAuthorized
2559 
    """
2560 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2561 
    return self.recv_markOrderDoaRequestAuthorized()
2562 
 
2563 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2564 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2565 
    args = markOrderDoaRequestAuthorized_args()
2566 
    args.orderId = orderId
2567 
    args.isAuthorized = isAuthorized
2568 
    args.write(self._oprot)
2569 
    self._oprot.writeMessageEnd()
2570 
    self._oprot.trans.flush()
2571 
 
2572 
  def recv_markOrderDoaRequestAuthorized(self, ):
2573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2574 
    if mtype == TMessageType.EXCEPTION:
2575 
      x = TApplicationException()
2576 
      x.read(self._iprot)
2577 
      self._iprot.readMessageEnd()
2578 
      raise x
2579 
    result = markOrderDoaRequestAuthorized_result()
2580 
    result.read(self._iprot)
2581 
    self._iprot.readMessageEnd()
2582 
    if result.success is not None:
2583 
      return result.success
2584 
    if result.ex is not None:
2585 
      raise result.ex
2586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2587 
 
4488 rajveer 2588 
  def markOrderReturnRequestReceived(self, orderId):
2589 
    """
2590 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2591 
 
2592 
    Parameters:
2593 
     - orderId
2594 
    """
2595 
    self.send_markOrderReturnRequestReceived(orderId)
2596 
    return self.recv_markOrderReturnRequestReceived()
2597 
 
2598 
  def send_markOrderReturnRequestReceived(self, orderId):
2599 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2600 
    args = markOrderReturnRequestReceived_args()
2601 
    args.orderId = orderId
2602 
    args.write(self._oprot)
2603 
    self._oprot.writeMessageEnd()
2604 
    self._oprot.trans.flush()
2605 
 
2606 
  def recv_markOrderReturnRequestReceived(self, ):
2607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2608 
    if mtype == TMessageType.EXCEPTION:
2609 
      x = TApplicationException()
2610 
      x.read(self._iprot)
2611 
      self._iprot.readMessageEnd()
2612 
      raise x
2613 
    result = markOrderReturnRequestReceived_result()
2614 
    result.read(self._iprot)
2615 
    self._iprot.readMessageEnd()
2616 
    if result.success is not None:
2617 
      return result.success
2618 
    if result.ex is not None:
2619 
      raise result.ex
2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2621 
 
2622 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2623 
    """
2624 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2625 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2626 
 
2627 
    Parameters:
2628 
     - orderId
2629 
     - isAuthorized
2630 
    """
2631 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2632 
    return self.recv_markOrderReturnRequestAuthorized()
2633 
 
2634 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2635 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2636 
    args = markOrderReturnRequestAuthorized_args()
2637 
    args.orderId = orderId
2638 
    args.isAuthorized = isAuthorized
2639 
    args.write(self._oprot)
2640 
    self._oprot.writeMessageEnd()
2641 
    self._oprot.trans.flush()
2642 
 
2643 
  def recv_markOrderReturnRequestAuthorized(self, ):
2644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2645 
    if mtype == TMessageType.EXCEPTION:
2646 
      x = TApplicationException()
2647 
      x.read(self._iprot)
2648 
      self._iprot.readMessageEnd()
2649 
      raise x
2650 
    result = markOrderReturnRequestAuthorized_result()
2651 
    result.read(self._iprot)
2652 
    self._iprot.readMessageEnd()
2653 
    if result.success is not None:
2654 
      return result.success
2655 
    if result.ex is not None:
2656 
      raise result.ex
2657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2658 
 
4579 rajveer 2659 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2660 
    """
2661 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2662 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2663 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2664 
    For any other status, it returns false.
2665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2666 
 
2536 chandransh 2667 
    Parameters:
2668 
     - orderId
4579 rajveer 2669 
     - providerId
2536 chandransh 2670 
    """
4579 rajveer 2671 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2672 
    return self.recv_requestPickupNumber()
2673 
 
4579 rajveer 2674 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2675 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2676 
    args = requestPickupNumber_args()
2677 
    args.orderId = orderId
4579 rajveer 2678 
    args.providerId = providerId
2536 chandransh 2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_requestPickupNumber(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = requestPickupNumber_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
3431 rajveer 2693 
    if result.success is not None:
2536 chandransh 2694 
      return result.success
3431 rajveer 2695 
    if result.ex is not None:
2536 chandransh 2696 
      raise result.ex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2698 
 
4602 rajveer 2699 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2700 
    """
4452 rajveer 2701 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2702 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2703 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2704 
    	3. Returns true
2591 chandransh 2705 
    If the order is in any other status, it returns false.
2536 chandransh 2706 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2707 
 
2536 chandransh 2708 
    Parameters:
2709 
     - orderId
2710 
     - pickupNumber
4602 rajveer 2711 
     - providerId
2536 chandransh 2712 
    """
4602 rajveer 2713 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2714 
    return self.recv_authorizePickup()
2715 
 
4602 rajveer 2716 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2717 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2718 
    args = authorizePickup_args()
2719 
    args.orderId = orderId
2720 
    args.pickupNumber = pickupNumber
4602 rajveer 2721 
    args.providerId = providerId
2536 chandransh 2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
2726 
  def recv_authorizePickup(self, ):
2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
2733 
    result = authorizePickup_result()
2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
3431 rajveer 2736 
    if result.success is not None:
2536 chandransh 2737 
      return result.success
3431 rajveer 2738 
    if result.ex is not None:
2536 chandransh 2739 
      raise result.ex
2740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2741 
 
2764 chandransh 2742 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2743 
    """
2744 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2745 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2746 
 
2764 chandransh 2747 
    Parameters:
2748 
     - providerId
2749 
     - pickupDetails
2750 
    """
2751 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2752 
    return self.recv_markDoasAsPickedUp()
2753 
 
2754 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2755 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2756 
    args = markDoasAsPickedUp_args()
2757 
    args.providerId = providerId
2758 
    args.pickupDetails = pickupDetails
2759 
    args.write(self._oprot)
2760 
    self._oprot.writeMessageEnd()
2761 
    self._oprot.trans.flush()
2762 
 
2763 
  def recv_markDoasAsPickedUp(self, ):
2764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2765 
    if mtype == TMessageType.EXCEPTION:
2766 
      x = TApplicationException()
2767 
      x.read(self._iprot)
2768 
      self._iprot.readMessageEnd()
2769 
      raise x
2770 
    result = markDoasAsPickedUp_result()
2771 
    result.read(self._iprot)
2772 
    self._iprot.readMessageEnd()
3431 rajveer 2773 
    if result.success is not None:
2764 chandransh 2774 
      return result.success
2775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2776 
 
4479 rajveer 2777 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2778 
    """
4452 rajveer 2779 
    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 2780 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2781 
    If the order is in any other state, it returns false.
2782 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2783 
 
2591 chandransh 2784 
    Parameters:
2785 
     - orderId
4479 rajveer 2786 
     - receiveCondition
2591 chandransh 2787 
    """
4479 rajveer 2788 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2789 
    return self.recv_receiveReturn()
2536 chandransh 2790 
 
4479 rajveer 2791 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2792 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2793 
    args = receiveReturn_args()
2591 chandransh 2794 
    args.orderId = orderId
4479 rajveer 2795 
    args.receiveCondition = receiveCondition
2591 chandransh 2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
2616 chandransh 2800 
  def recv_receiveReturn(self, ):
2591 chandransh 2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
2616 chandransh 2807 
    result = receiveReturn_result()
2591 chandransh 2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
3431 rajveer 2810 
    if result.success is not None:
2591 chandransh 2811 
      return result.success
3431 rajveer 2812 
    if result.ex is not None:
2591 chandransh 2813 
      raise result.ex
2616 chandransh 2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2815 
 
2816 
  def validateDoa(self, orderId, isValid):
2817 
    """
4452 rajveer 2818 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2819 
    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 2820 
    If the order is in any other state, it returns false.
2821 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2822 
 
2591 chandransh 2823 
    Parameters:
2824 
     - orderId
2825 
     - isValid
2826 
    """
2827 
    self.send_validateDoa(orderId, isValid)
2828 
    return self.recv_validateDoa()
2829 
 
2830 
  def send_validateDoa(self, orderId, isValid):
2831 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2832 
    args = validateDoa_args()
2833 
    args.orderId = orderId
2834 
    args.isValid = isValid
2835 
    args.write(self._oprot)
2836 
    self._oprot.writeMessageEnd()
2837 
    self._oprot.trans.flush()
2838 
 
2839 
  def recv_validateDoa(self, ):
2840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2841 
    if mtype == TMessageType.EXCEPTION:
2842 
      x = TApplicationException()
2843 
      x.read(self._iprot)
2844 
      self._iprot.readMessageEnd()
2845 
      raise x
2846 
    result = validateDoa_result()
2847 
    result.read(self._iprot)
2848 
    self._iprot.readMessageEnd()
3431 rajveer 2849 
    if result.success is not None:
2591 chandransh 2850 
      return result.success
3431 rajveer 2851 
    if result.ex is not None:
2591 chandransh 2852 
      raise result.ex
2853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2854 
 
4495 rajveer 2855 
  def validateReturnProduct(self, orderId, isUsable):
2856 
    """
2857 
    Parameters:
2858 
     - orderId
2859 
     - isUsable
2860 
    """
2861 
    self.send_validateReturnProduct(orderId, isUsable)
2862 
    return self.recv_validateReturnProduct()
2863 
 
2864 
  def send_validateReturnProduct(self, orderId, isUsable):
2865 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2866 
    args = validateReturnProduct_args()
2867 
    args.orderId = orderId
2868 
    args.isUsable = isUsable
2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
2873 
  def recv_validateReturnProduct(self, ):
2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
2880 
    result = validateReturnProduct_result()
2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
2883 
    if result.success is not None:
2884 
      return result.success
2885 
    if result.ex is not None:
2886 
      raise result.ex
2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2888 
 
2616 chandransh 2889 
  def reshipOrder(self, orderId):
2890 
    """
4484 rajveer 2891 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2892 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2893 
    	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 2894 
 
2895 
    If the order is in DOA_CERT_VALID state, it does the following:
2896 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2897 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2898 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2899 
 
2616 chandransh 2900 
    Returns the id of the newly created order.
3431 rajveer 2901 
 
2616 chandransh 2902 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2903 
 
2616 chandransh 2904 
    Parameters:
2905 
     - orderId
2906 
    """
2907 
    self.send_reshipOrder(orderId)
2908 
    return self.recv_reshipOrder()
2591 chandransh 2909 
 
2616 chandransh 2910 
  def send_reshipOrder(self, orderId):
2911 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2912 
    args = reshipOrder_args()
2913 
    args.orderId = orderId
2914 
    args.write(self._oprot)
2915 
    self._oprot.writeMessageEnd()
2916 
    self._oprot.trans.flush()
2917 
 
2918 
  def recv_reshipOrder(self, ):
2919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2920 
    if mtype == TMessageType.EXCEPTION:
2921 
      x = TApplicationException()
2922 
      x.read(self._iprot)
2923 
      self._iprot.readMessageEnd()
2924 
      raise x
2925 
    result = reshipOrder_result()
2926 
    result.read(self._iprot)
2927 
    self._iprot.readMessageEnd()
3431 rajveer 2928 
    if result.success is not None:
2616 chandransh 2929 
      return result.success
3431 rajveer 2930 
    if result.ex is not None:
2616 chandransh 2931 
      raise result.ex
2932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2933 
 
3226 chandransh 2934 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2935 
    """
4484 rajveer 2936 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2937 
    	1. Creates a refund request for batch processing.
2938 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2939 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2940 
 
2616 chandransh 2941 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2942 
    	1. Creates a refund request for batch processing.
3226 chandransh 2943 
    	2. Cancels the reservation of the item in the warehouse.
2944 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2945 
 
3226 chandransh 2946 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2947 
    	1. Cancels the reservation of the item in the warehouse.
2948 
    	2. Marks the current order as CANCELED.
2949 
 
2950 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2951 
 
2616 chandransh 2952 
    Returns True if it is successful, False otherwise.
3431 rajveer 2953 
 
2616 chandransh 2954 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2955 
 
2616 chandransh 2956 
    Parameters:
2957 
     - orderId
3226 chandransh 2958 
     - refundedBy
2959 
     - reason
2616 chandransh 2960 
    """
3226 chandransh 2961 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2962 
    return self.recv_refundOrder()
2963 
 
3226 chandransh 2964 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2965 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2966 
    args = refundOrder_args()
2967 
    args.orderId = orderId
3226 chandransh 2968 
    args.refundedBy = refundedBy
2969 
    args.reason = reason
2616 chandransh 2970 
    args.write(self._oprot)
2971 
    self._oprot.writeMessageEnd()
2972 
    self._oprot.trans.flush()
2973 
 
2974 
  def recv_refundOrder(self, ):
2975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2976 
    if mtype == TMessageType.EXCEPTION:
2977 
      x = TApplicationException()
2978 
      x.read(self._iprot)
2979 
      self._iprot.readMessageEnd()
2980 
      raise x
2981 
    result = refundOrder_result()
2982 
    result.read(self._iprot)
2983 
    self._iprot.readMessageEnd()
3431 rajveer 2984 
    if result.success is not None:
2616 chandransh 2985 
      return result.success
3431 rajveer 2986 
    if result.ex is not None:
2616 chandransh 2987 
      raise result.ex
2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2989 
 
2690 chandransh 2990 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2991 
    """
2992 
    Get all return orders created between the from and to dates for the given warehouse.
2993 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2994 
 
2690 chandransh 2995 
    Parameters:
2996 
     - warehouseId
2997 
     - fromDate
2998 
     - toDate
2999 
    """
3000 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3001 
    return self.recv_getReturnOrders()
2616 chandransh 3002 
 
2690 chandransh 3003 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3004 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3005 
    args = getReturnOrders_args()
3006 
    args.warehouseId = warehouseId
3007 
    args.fromDate = fromDate
3008 
    args.toDate = toDate
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_getReturnOrders(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = getReturnOrders_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3431 rajveer 3023 
    if result.success is not None:
2690 chandransh 3024 
      return result.success
3025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3026 
 
2700 chandransh 3027 
  def getReturnOrder(self, id):
3028 
    """
3029 
    Returns the ReturnOrder corresponding to the given id.
3030 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3031 
 
2700 chandransh 3032 
    Parameters:
3033 
     - id
3034 
    """
3035 
    self.send_getReturnOrder(id)
3036 
    return self.recv_getReturnOrder()
3037 
 
3038 
  def send_getReturnOrder(self, id):
3039 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3040 
    args = getReturnOrder_args()
3041 
    args.id = id
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_getReturnOrder(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = getReturnOrder_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3431 rajveer 3056 
    if result.success is not None:
2700 chandransh 3057 
      return result.success
3431 rajveer 3058 
    if result.ex is not None:
2700 chandransh 3059 
      raise result.ex
3060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3061 
 
2690 chandransh 3062 
  def processReturn(self, returnOrderId):
3063 
    """
3064 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3065 
 
2690 chandransh 3066 
    Parameters:
3067 
     - returnOrderId
3068 
    """
3069 
    self.send_processReturn(returnOrderId)
3070 
    self.recv_processReturn()
3071 
 
3072 
  def send_processReturn(self, returnOrderId):
3073 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3074 
    args = processReturn_args()
3075 
    args.returnOrderId = returnOrderId
3076 
    args.write(self._oprot)
3077 
    self._oprot.writeMessageEnd()
3078 
    self._oprot.trans.flush()
3079 
 
3080 
  def recv_processReturn(self, ):
3081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3082 
    if mtype == TMessageType.EXCEPTION:
3083 
      x = TApplicationException()
3084 
      x.read(self._iprot)
3085 
      self._iprot.readMessageEnd()
3086 
      raise x
3087 
    result = processReturn_result()
3088 
    result.read(self._iprot)
3089 
    self._iprot.readMessageEnd()
3431 rajveer 3090 
    if result.ex is not None:
2690 chandransh 3091 
      raise result.ex
3092 
    return
3093 
 
2819 chandransh 3094 
  def createPurchaseOrder(self, warehouseId):
3095 
    """
4586 mandeep.dh 3096 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3097 
    Returns the list of PO no. of the newly created purchase order.
3098 
    Returns null if no new purchase order had to be created.
3431 rajveer 3099 
 
2819 chandransh 3100 
    Parameters:
3101 
     - warehouseId
3102 
    """
3103 
    self.send_createPurchaseOrder(warehouseId)
3104 
    return self.recv_createPurchaseOrder()
2690 chandransh 3105 
 
2819 chandransh 3106 
  def send_createPurchaseOrder(self, warehouseId):
3107 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3108 
    args = createPurchaseOrder_args()
3109 
    args.warehouseId = warehouseId
3110 
    args.write(self._oprot)
3111 
    self._oprot.writeMessageEnd()
3112 
    self._oprot.trans.flush()
3113 
 
3114 
  def recv_createPurchaseOrder(self, ):
3115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3116 
    if mtype == TMessageType.EXCEPTION:
3117 
      x = TApplicationException()
3118 
      x.read(self._iprot)
3119 
      self._iprot.readMessageEnd()
3120 
      raise x
3121 
    result = createPurchaseOrder_result()
3122 
    result.read(self._iprot)
3123 
    self._iprot.readMessageEnd()
3431 rajveer 3124 
    if result.success is not None:
2819 chandransh 3125 
      return result.success
3431 rajveer 3126 
    if result.ex is not None:
2819 chandransh 3127 
      raise result.ex
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3129 
 
3451 chandransh 3130 
  def updateWeight(self, orderId, weight):
3131 
    """
3132 
    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 3133 
 
3451 chandransh 3134 
    Parameters:
3135 
     - orderId
3136 
     - weight
3137 
    """
3138 
    self.send_updateWeight(orderId, weight)
3139 
    return self.recv_updateWeight()
3140 
 
3141 
  def send_updateWeight(self, orderId, weight):
3142 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3143 
    args = updateWeight_args()
3144 
    args.orderId = orderId
3145 
    args.weight = weight
3146 
    args.write(self._oprot)
3147 
    self._oprot.writeMessageEnd()
3148 
    self._oprot.trans.flush()
3149 
 
3150 
  def recv_updateWeight(self, ):
3151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3152 
    if mtype == TMessageType.EXCEPTION:
3153 
      x = TApplicationException()
3154 
      x.read(self._iprot)
3155 
      self._iprot.readMessageEnd()
3156 
      raise x
3157 
    result = updateWeight_result()
3158 
    result.read(self._iprot)
3159 
    self._iprot.readMessageEnd()
3160 
    if result.success is not None:
3161 
      return result.success
3162 
    if result.ex is not None:
3163 
      raise result.ex
3164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3165 
 
3469 chandransh 3166 
  def changeItem(self, orderId, itemId):
3167 
    """
3168 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3169 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3170 
 
3469 chandransh 3171 
    Parameters:
3172 
     - orderId
3173 
     - itemId
3174 
    """
3175 
    self.send_changeItem(orderId, itemId)
3176 
    return self.recv_changeItem()
3177 
 
3178 
  def send_changeItem(self, orderId, itemId):
3179 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3180 
    args = changeItem_args()
3181 
    args.orderId = orderId
3182 
    args.itemId = itemId
3183 
    args.write(self._oprot)
3184 
    self._oprot.writeMessageEnd()
3185 
    self._oprot.trans.flush()
3186 
 
3187 
  def recv_changeItem(self, ):
3188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3189 
    if mtype == TMessageType.EXCEPTION:
3190 
      x = TApplicationException()
3191 
      x.read(self._iprot)
3192 
      self._iprot.readMessageEnd()
3193 
      raise x
3194 
    result = changeItem_result()
3195 
    result.read(self._iprot)
3196 
    self._iprot.readMessageEnd()
3197 
    if result.success is not None:
3198 
      return result.success
3199 
    if result.ex is not None:
3200 
      raise result.ex
3201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3202 
 
3203 
  def shiftToWarehouse(self, orderId, warehouseId):
3204 
    """
3205 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3206 
 
3207 
    Parameters:
3208 
     - orderId
3209 
     - warehouseId
3210 
    """
3211 
    self.send_shiftToWarehouse(orderId, warehouseId)
3212 
    return self.recv_shiftToWarehouse()
3213 
 
3214 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3215 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3216 
    args = shiftToWarehouse_args()
3217 
    args.orderId = orderId
3218 
    args.warehouseId = warehouseId
3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3223 
  def recv_shiftToWarehouse(self, ):
3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3230 
    result = shiftToWarehouse_result()
3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3233 
    if result.success is not None:
3234 
      return result.success
3235 
    if result.ex is not None:
3236 
      raise result.ex
3237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3238 
 
4647 rajveer 3239 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3240 
    """
3241 
    Adds the given delay reason to the given order.
3986 chandransh 3242 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3243 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3244 
 
3553 chandransh 3245 
    Parameters:
3246 
     - orderId
3247 
     - delayReason
3986 chandransh 3248 
     - furtherDelay
4647 rajveer 3249 
     - delayReasonText
3553 chandransh 3250 
    """
4647 rajveer 3251 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3252 
    return self.recv_addDelayReason()
3253 
 
4647 rajveer 3254 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3255 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3256 
    args = addDelayReason_args()
3257 
    args.orderId = orderId
3258 
    args.delayReason = delayReason
3986 chandransh 3259 
    args.furtherDelay = furtherDelay
4647 rajveer 3260 
    args.delayReasonText = delayReasonText
3553 chandransh 3261 
    args.write(self._oprot)
3262 
    self._oprot.writeMessageEnd()
3263 
    self._oprot.trans.flush()
3264 
 
3265 
  def recv_addDelayReason(self, ):
3266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3267 
    if mtype == TMessageType.EXCEPTION:
3268 
      x = TApplicationException()
3269 
      x.read(self._iprot)
3270 
      self._iprot.readMessageEnd()
3271 
      raise x
3272 
    result = addDelayReason_result()
3273 
    result.read(self._iprot)
3274 
    self._iprot.readMessageEnd()
3275 
    if result.success is not None:
3276 
      return result.success
3277 
    if result.ex is not None:
3278 
      raise result.ex
3279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3280 
 
3956 chandransh 3281 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3282 
    """
3283 
    Marks the COD orders with given AWB nos. as having been processed.
3284 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3285 
 
3956 chandransh 3286 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3287 
    1. There is no order corresponding to an AWB number.
3288 
    2. The captured amount for a payment exceeds the total payment.
3289 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3290 
 
3291 
    Parameters:
3292 
     - collectedAmountMap
3293 
     - xferBy
3294 
     - xferTxnId
3295 
     - xferDate
3296 
    """
3297 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3298 
    return self.recv_reconcileCodCollection()
3299 
 
3300 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3301 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3302 
    args = reconcileCodCollection_args()
3303 
    args.collectedAmountMap = collectedAmountMap
3304 
    args.xferBy = xferBy
3305 
    args.xferTxnId = xferTxnId
3306 
    args.xferDate = xferDate
3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_reconcileCodCollection(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = reconcileCodCollection_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
3321 
    if result.success is not None:
3322 
      return result.success
3323 
    if result.ex is not None:
3324 
      raise result.ex
3325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3326 
 
4008 mandeep.dh 3327 
  def getTransactionsRequiringExtraProcessing(self, category):
3328 
    """
4065 mandeep.dh 3329 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3330 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3331 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3332 
 
4008 mandeep.dh 3333 
    Parameters:
3334 
     - category
3335 
    """
3336 
    self.send_getTransactionsRequiringExtraProcessing(category)
3337 
    return self.recv_getTransactionsRequiringExtraProcessing()
3338 
 
3339 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3340 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3341 
    args = getTransactionsRequiringExtraProcessing_args()
3342 
    args.category = category
3343 
    args.write(self._oprot)
3344 
    self._oprot.writeMessageEnd()
3345 
    self._oprot.trans.flush()
3346 
 
3347 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3349 
    if mtype == TMessageType.EXCEPTION:
3350 
      x = TApplicationException()
3351 
      x.read(self._iprot)
3352 
      self._iprot.readMessageEnd()
3353 
      raise x
3354 
    result = getTransactionsRequiringExtraProcessing_result()
3355 
    result.read(self._iprot)
3356 
    self._iprot.readMessageEnd()
3357 
    if result.success is not None:
3358 
      return result.success
3359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3360 
 
3361 
  def markTransactionAsProcessed(self, transactionId, category):
3362 
    """
3363 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3364 
    It essentially deletes the transaction id record for a particular
3365 
    processing type category (if present) from DB.
3366 
    This is currently used by CRM application.
4008 mandeep.dh 3367 
 
3368 
    Parameters:
3369 
     - transactionId
3370 
     - category
3371 
    """
3372 
    self.send_markTransactionAsProcessed(transactionId, category)
3373 
    self.recv_markTransactionAsProcessed()
3374 
 
3375 
  def send_markTransactionAsProcessed(self, transactionId, category):
3376 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3377 
    args = markTransactionAsProcessed_args()
3378 
    args.transactionId = transactionId
3379 
    args.category = category
3380 
    args.write(self._oprot)
3381 
    self._oprot.writeMessageEnd()
3382 
    self._oprot.trans.flush()
3383 
 
3384 
  def recv_markTransactionAsProcessed(self, ):
3385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3386 
    if mtype == TMessageType.EXCEPTION:
3387 
      x = TApplicationException()
3388 
      x.read(self._iprot)
3389 
      self._iprot.readMessageEnd()
3390 
      raise x
3391 
    result = markTransactionAsProcessed_result()
3392 
    result.read(self._iprot)
3393 
    self._iprot.readMessageEnd()
3394 
    return
3395 
 
4018 chandransh 3396 
  def getItemWiseRiskyOrdersCount(self, ):
3397 
    """
3398 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3399 
    is defined as one whose shipping date is about to expire.
3400 
    """
3401 
    self.send_getItemWiseRiskyOrdersCount()
3402 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3403 
 
4018 chandransh 3404 
  def send_getItemWiseRiskyOrdersCount(self, ):
3405 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3406 
    args = getItemWiseRiskyOrdersCount_args()
3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = getItemWiseRiskyOrdersCount_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3421 
    if result.success is not None:
3422 
      return result.success
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3424 
 
4295 varun.gupt 3425 
  def getOrdersForItemIds(self, itemIds):
3426 
    """
3427 
    Returns a list of all orders which have items with given id
3428 
 
3429 
    Parameters:
3430 
     - itemIds
3431 
    """
3432 
    self.send_getOrdersForItemIds(itemIds)
3433 
    return self.recv_getOrdersForItemIds()
3434 
 
3435 
  def send_getOrdersForItemIds(self, itemIds):
3436 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3437 
    args = getOrdersForItemIds_args()
3438 
    args.itemIds = itemIds
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_getOrdersForItemIds(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = getOrdersForItemIds_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    if result.success is not None:
3454 
      return result.success
3455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3456 
 
4247 rajveer 3457 
  def markOrderCancellationRequestReceived(self, orderId):
3458 
    """
3459 
    Mark order as cancellation request received. If customer sends request of cancellation of
3460 
    a particular order, this method will be called. It will just change status of the order
3461 
    depending on its current status. It also records the previous status, so that we can move
3462 
    back to that status if cancellation request is denied.
4018 chandransh 3463 
 
4247 rajveer 3464 
    Parameters:
3465 
     - orderId
3466 
    """
3467 
    self.send_markOrderCancellationRequestReceived(orderId)
3468 
    self.recv_markOrderCancellationRequestReceived()
3469 
 
3470 
  def send_markOrderCancellationRequestReceived(self, orderId):
3471 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3472 
    args = markOrderCancellationRequestReceived_args()
3473 
    args.orderId = orderId
3474 
    args.write(self._oprot)
3475 
    self._oprot.writeMessageEnd()
3476 
    self._oprot.trans.flush()
3477 
 
3478 
  def recv_markOrderCancellationRequestReceived(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 = markOrderCancellationRequestReceived_result()
3486 
    result.read(self._iprot)
3487 
    self._iprot.readMessageEnd()
3488 
    if result.ex is not None:
3489 
      raise result.ex
3490 
    return
3491 
 
3492 
  def markOrderCancellationRequestConfirmed(self, orderId):
3493 
    """
3494 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3495 
    cancellation request confirmed. After this OM will be able to cancel the order.
3496 
 
3497 
    Parameters:
3498 
     - orderId
3499 
    """
3500 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3501 
    self.recv_markOrderCancellationRequestConfirmed()
3502 
 
3503 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3504 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3505 
    args = markOrderCancellationRequestConfirmed_args()
3506 
    args.orderId = orderId
3507 
    args.write(self._oprot)
3508 
    self._oprot.writeMessageEnd()
3509 
    self._oprot.trans.flush()
3510 
 
3511 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3513 
    if mtype == TMessageType.EXCEPTION:
3514 
      x = TApplicationException()
3515 
      x.read(self._iprot)
3516 
      self._iprot.readMessageEnd()
3517 
      raise x
3518 
    result = markOrderCancellationRequestConfirmed_result()
3519 
    result.read(self._iprot)
3520 
    self._iprot.readMessageEnd()
3521 
    if result.ex is not None:
3522 
      raise result.ex
3523 
    return
3524 
 
3525 
  def markOrderCancellationRequestDenied(self, orderId):
3526 
    """
3527 
    If we decide to not to cancel order, we will move the order ro previous status.
3528 
 
3529 
    Parameters:
3530 
     - orderId
3531 
    """
3532 
    self.send_markOrderCancellationRequestDenied(orderId)
3533 
    self.recv_markOrderCancellationRequestDenied()
3534 
 
3535 
  def send_markOrderCancellationRequestDenied(self, orderId):
3536 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3537 
    args = markOrderCancellationRequestDenied_args()
3538 
    args.orderId = orderId
3539 
    args.write(self._oprot)
3540 
    self._oprot.writeMessageEnd()
3541 
    self._oprot.trans.flush()
3542 
 
3543 
  def recv_markOrderCancellationRequestDenied(self, ):
3544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3545 
    if mtype == TMessageType.EXCEPTION:
3546 
      x = TApplicationException()
3547 
      x.read(self._iprot)
3548 
      self._iprot.readMessageEnd()
3549 
      raise x
3550 
    result = markOrderCancellationRequestDenied_result()
3551 
    result.read(self._iprot)
3552 
    self._iprot.readMessageEnd()
3553 
    if result.ex is not None:
3554 
      raise result.ex
3555 
    return
3556 
 
4258 rajveer 3557 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3558 
    """
4258 rajveer 3559 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3560 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3561 
 
3562 
    Parameters:
4258 rajveer 3563 
     - transactionId
4247 rajveer 3564 
    """
4258 rajveer 3565 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3566 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3567 
 
4258 rajveer 3568 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3569 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3570 
    args = markTransactionAsPaymentFlagRemoved_args()
3571 
    args.transactionId = transactionId
4247 rajveer 3572 
    args.write(self._oprot)
3573 
    self._oprot.writeMessageEnd()
3574 
    self._oprot.trans.flush()
3575 
 
4258 rajveer 3576 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3578 
    if mtype == TMessageType.EXCEPTION:
3579 
      x = TApplicationException()
3580 
      x.read(self._iprot)
3581 
      self._iprot.readMessageEnd()
3582 
      raise x
4258 rajveer 3583 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3584 
    result.read(self._iprot)
3585 
    self._iprot.readMessageEnd()
3586 
    if result.ex is not None:
3587 
      raise result.ex
3588 
    return
3589 
 
4259 anupam.sin 3590 
  def refundTransaction(self, transactionId, refundedBy, reason):
3591 
    """
3592 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3593 
    need to be cancelled
4247 rajveer 3594 
 
4259 anupam.sin 3595 
    Parameters:
3596 
     - transactionId
3597 
     - refundedBy
3598 
     - reason
3599 
    """
3600 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3601 
    self.recv_refundTransaction()
3602 
 
3603 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3604 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3605 
    args = refundTransaction_args()
3606 
    args.transactionId = transactionId
3607 
    args.refundedBy = refundedBy
3608 
    args.reason = reason
3609 
    args.write(self._oprot)
3610 
    self._oprot.writeMessageEnd()
3611 
    self._oprot.trans.flush()
3612 
 
3613 
  def recv_refundTransaction(self, ):
3614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3615 
    if mtype == TMessageType.EXCEPTION:
3616 
      x = TApplicationException()
3617 
      x.read(self._iprot)
3618 
      self._iprot.readMessageEnd()
3619 
      raise x
3620 
    result = refundTransaction_result()
3621 
    result.read(self._iprot)
3622 
    self._iprot.readMessageEnd()
3623 
    if result.ex is not None:
3624 
      raise result.ex
3625 
    return
3626 
 
4324 mandeep.dh 3627 
  def updateShipmentAddress(self, orderId, addressId):
3628 
    """
3629 
    Updates shipment address of an order. Delivery and shipping date estimates
3630 
    etc. are also updated here.
3631 
 
3632 
    Throws TransactionServiceException in case address change is not
3633 
    possible due to certain reasons such as new pincode in address is
3634 
    not serviceable etc.
3635 
 
3636 
    Parameters:
3637 
     - orderId
3638 
     - addressId
3639 
    """
3640 
    self.send_updateShipmentAddress(orderId, addressId)
3641 
    self.recv_updateShipmentAddress()
3642 
 
3643 
  def send_updateShipmentAddress(self, orderId, addressId):
3644 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3645 
    args = updateShipmentAddress_args()
3646 
    args.orderId = orderId
3647 
    args.addressId = addressId
3648 
    args.write(self._oprot)
3649 
    self._oprot.writeMessageEnd()
3650 
    self._oprot.trans.flush()
3651 
 
3652 
  def recv_updateShipmentAddress(self, ):
3653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3654 
    if mtype == TMessageType.EXCEPTION:
3655 
      x = TApplicationException()
3656 
      x.read(self._iprot)
3657 
      self._iprot.readMessageEnd()
3658 
      raise x
3659 
    result = updateShipmentAddress_result()
3660 
    result.read(self._iprot)
3661 
    self._iprot.readMessageEnd()
3662 
    if result.ex is not None:
3663 
      raise result.ex
3664 
    return
3665 
 
4285 rajveer 3666 
  def acceptOrdersForItemId(self, itemId, inventory):
3667 
    """
3668 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3669 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3670 
 
4285 rajveer 3671 
    Parameters:
3672 
     - itemId
3673 
     - inventory
3674 
    """
3675 
    self.send_acceptOrdersForItemId(itemId, inventory)
3676 
    return self.recv_acceptOrdersForItemId()
3677 
 
3678 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3679 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3680 
    args = acceptOrdersForItemId_args()
3681 
    args.itemId = itemId
3682 
    args.inventory = inventory
3683 
    args.write(self._oprot)
3684 
    self._oprot.writeMessageEnd()
3685 
    self._oprot.trans.flush()
3686 
 
3687 
  def recv_acceptOrdersForItemId(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 = acceptOrdersForItemId_result()
3695 
    result.read(self._iprot)
3696 
    self._iprot.readMessageEnd()
3697 
    if result.success is not None:
3698 
      return result.success
3699 
    if result.ex is not None:
3700 
      raise result.ex
3701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3702 
 
4369 rajveer 3703 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3704 
    """
3705 
    Parameters:
3706 
     - vendorId
3707 
     - itemId
3708 
     - quantity
3709 
     - estimate
4369 rajveer 3710 
     - isReminder
4303 rajveer 3711 
    """
4369 rajveer 3712 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3713 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3714 
 
4369 rajveer 3715 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3716 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3717 
    args = markOrdersAsPORaised_args()
3718 
    args.vendorId = vendorId
3719 
    args.itemId = itemId
3720 
    args.quantity = quantity
3721 
    args.estimate = estimate
4369 rajveer 3722 
    args.isReminder = isReminder
4303 rajveer 3723 
    args.write(self._oprot)
3724 
    self._oprot.writeMessageEnd()
3725 
    self._oprot.trans.flush()
3726 
 
3727 
  def recv_markOrdersAsPORaised(self, ):
3728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3729 
    if mtype == TMessageType.EXCEPTION:
3730 
      x = TApplicationException()
3731 
      x.read(self._iprot)
3732 
      self._iprot.readMessageEnd()
3733 
      raise x
3734 
    result = markOrdersAsPORaised_result()
3735 
    result.read(self._iprot)
3736 
    self._iprot.readMessageEnd()
3737 
    if result.ex is not None:
3738 
      raise result.ex
3739 
    return
3740 
 
4369 rajveer 3741 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3742 
    """
3743 
    Parameters:
3744 
     - vendorId
3745 
     - itemId
3746 
     - quantity
3747 
     - estimate
4369 rajveer 3748 
     - isReminder
4303 rajveer 3749 
    """
4369 rajveer 3750 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3751 
    self.recv_markOrdersAsReversalInitiated()
3752 
 
4369 rajveer 3753 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3754 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3755 
    args = markOrdersAsReversalInitiated_args()
3756 
    args.vendorId = vendorId
3757 
    args.itemId = itemId
3758 
    args.quantity = quantity
3759 
    args.estimate = estimate
4369 rajveer 3760 
    args.isReminder = isReminder
4303 rajveer 3761 
    args.write(self._oprot)
3762 
    self._oprot.writeMessageEnd()
3763 
    self._oprot.trans.flush()
3764 
 
3765 
  def recv_markOrdersAsReversalInitiated(self, ):
3766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3767 
    if mtype == TMessageType.EXCEPTION:
3768 
      x = TApplicationException()
3769 
      x.read(self._iprot)
3770 
      self._iprot.readMessageEnd()
3771 
      raise x
3772 
    result = markOrdersAsReversalInitiated_result()
3773 
    result.read(self._iprot)
3774 
    self._iprot.readMessageEnd()
3775 
    if result.ex is not None:
3776 
      raise result.ex
3777 
    return
3778 
 
4369 rajveer 3779 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3780 
    """
3781 
    Parameters:
3782 
     - vendorId
3783 
     - itemId
3784 
     - quantity
3785 
     - estimate
4369 rajveer 3786 
     - isReminder
4303 rajveer 3787 
    """
4369 rajveer 3788 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3789 
    self.recv_markOrdersAsNotAvailabke()
3790 
 
4369 rajveer 3791 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3792 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3793 
    args = markOrdersAsNotAvailabke_args()
3794 
    args.vendorId = vendorId
3795 
    args.itemId = itemId
3796 
    args.quantity = quantity
3797 
    args.estimate = estimate
4369 rajveer 3798 
    args.isReminder = isReminder
4303 rajveer 3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_markOrdersAsNotAvailabke(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = markOrdersAsNotAvailabke_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.ex is not None:
3814 
      raise result.ex
3815 
    return
3816 
 
4369 rajveer 3817 
  def markOrdersAsTimeout(self, vendorId):
3818 
    """
3819 
    Parameters:
3820 
     - vendorId
3821 
    """
3822 
    self.send_markOrdersAsTimeout(vendorId)
3823 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3824 
 
4369 rajveer 3825 
  def send_markOrdersAsTimeout(self, vendorId):
3826 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3827 
    args = markOrdersAsTimeout_args()
3828 
    args.vendorId = vendorId
3829 
    args.write(self._oprot)
3830 
    self._oprot.writeMessageEnd()
3831 
    self._oprot.trans.flush()
3832 
 
3833 
  def recv_markOrdersAsTimeout(self, ):
3834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3835 
    if mtype == TMessageType.EXCEPTION:
3836 
      x = TApplicationException()
3837 
      x.read(self._iprot)
3838 
      self._iprot.readMessageEnd()
3839 
      raise x
3840 
    result = markOrdersAsTimeout_result()
3841 
    result.read(self._iprot)
3842 
    self._iprot.readMessageEnd()
3843 
    if result.success is not None:
3844 
      return result.success
3845 
    if result.ex is not None:
3846 
      raise result.ex
3847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3848 
 
4662 rajveer 3849 
  def markOrderAsLostInTransit(self, orderId):
3850 
    """
3851 
    Mark order as LOST_IN_TRANSIT
3852 
 
3853 
    Parameters:
3854 
     - orderId
3855 
    """
3856 
    self.send_markOrderAsLostInTransit(orderId)
3857 
    return self.recv_markOrderAsLostInTransit()
3858 
 
3859 
  def send_markOrderAsLostInTransit(self, orderId):
3860 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3861 
    args = markOrderAsLostInTransit_args()
3862 
    args.orderId = orderId
3863 
    args.write(self._oprot)
3864 
    self._oprot.writeMessageEnd()
3865 
    self._oprot.trans.flush()
3866 
 
3867 
  def recv_markOrderAsLostInTransit(self, ):
3868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3869 
    if mtype == TMessageType.EXCEPTION:
3870 
      x = TApplicationException()
3871 
      x.read(self._iprot)
3872 
      self._iprot.readMessageEnd()
3873 
      raise x
3874 
    result = markOrderAsLostInTransit_result()
3875 
    result.read(self._iprot)
3876 
    self._iprot.readMessageEnd()
3877 
    if result.success is not None:
3878 
      return result.success
3879 
    if result.ex is not None:
3880 
      raise result.ex
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3882 
 
4386 anupam.sin 3883 
  def getOrderForAwb(self, awb):
3884 
    """
3885 
    Returns the order corresponding to an AWB number
4369 rajveer 3886 
 
4386 anupam.sin 3887 
    Parameters:
3888 
     - awb
3889 
    """
3890 
    self.send_getOrderForAwb(awb)
3891 
    return self.recv_getOrderForAwb()
3892 
 
3893 
  def send_getOrderForAwb(self, awb):
3894 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3895 
    args = getOrderForAwb_args()
3896 
    args.awb = awb
3897 
    args.write(self._oprot)
3898 
    self._oprot.writeMessageEnd()
3899 
    self._oprot.trans.flush()
3900 
 
3901 
  def recv_getOrderForAwb(self, ):
3902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3903 
    if mtype == TMessageType.EXCEPTION:
3904 
      x = TApplicationException()
3905 
      x.read(self._iprot)
3906 
      self._iprot.readMessageEnd()
3907 
      raise x
3908 
    result = getOrderForAwb_result()
3909 
    result.read(self._iprot)
3910 
    self._iprot.readMessageEnd()
3911 
    if result.success is not None:
3912 
      return result.success
3913 
    if result.ex is not None:
3914 
      raise result.ex
3915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3916 
 
4506 phani.kuma 3917 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3918 
    """
3919 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3920 
 
4506 phani.kuma 3921 
    Parameters:
3922 
     - logistics_provider_id
3923 
     - order_status
3924 
    """
3925 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3926 
    return self.recv_getOrdersForProviderForStatus()
3927 
 
3928 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3929 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3930 
    args = getOrdersForProviderForStatus_args()
3931 
    args.logistics_provider_id = logistics_provider_id
3932 
    args.order_status = order_status
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_getOrdersForProviderForStatus(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = getOrdersForProviderForStatus_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    if result.success is not None:
3948 
      return result.success
3949 
    if result.ex is not None:
3950 
      raise result.ex
3951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3952 
 
4600 varun.gupt 3953 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3954 
    """
3955 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3956 
 
4600 varun.gupt 3957 
    Parameters:
3958 
     - vendorId
3959 
     - billingDateFrom
3960 
     - billingDateTo
3961 
    """
3962 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3963 
    return self.recv_getBilledOrdersForVendor()
3964 
 
3965 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3966 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3967 
    args = getBilledOrdersForVendor_args()
3968 
    args.vendorId = vendorId
3969 
    args.billingDateFrom = billingDateFrom
3970 
    args.billingDateTo = billingDateTo
3971 
    args.write(self._oprot)
3972 
    self._oprot.writeMessageEnd()
3973 
    self._oprot.trans.flush()
3974 
 
3975 
  def recv_getBilledOrdersForVendor(self, ):
3976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3977 
    if mtype == TMessageType.EXCEPTION:
3978 
      x = TApplicationException()
3979 
      x.read(self._iprot)
3980 
      self._iprot.readMessageEnd()
3981 
      raise x
3982 
    result = getBilledOrdersForVendor_result()
3983 
    result.read(self._iprot)
3984 
    self._iprot.readMessageEnd()
3985 
    if result.success is not None:
3986 
      return result.success
3987 
    if result.ex is not None:
3988 
      raise result.ex
3989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3990 
 
4607 rajveer 3991 
  def getSlippedSippingDateOrders(self, ):
3992 
    self.send_getSlippedSippingDateOrders()
3993 
    return self.recv_getSlippedSippingDateOrders()
3994 
 
3995 
  def send_getSlippedSippingDateOrders(self, ):
3996 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
3997 
    args = getSlippedSippingDateOrders_args()
3998 
    args.write(self._oprot)
3999 
    self._oprot.writeMessageEnd()
4000 
    self._oprot.trans.flush()
4001 
 
4002 
  def recv_getSlippedSippingDateOrders(self, ):
4003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4004 
    if mtype == TMessageType.EXCEPTION:
4005 
      x = TApplicationException()
4006 
      x.read(self._iprot)
4007 
      self._iprot.readMessageEnd()
4008 
      raise x
4009 
    result = getSlippedSippingDateOrders_result()
4010 
    result.read(self._iprot)
4011 
    self._iprot.readMessageEnd()
4012 
    if result.success is not None:
4013 
      return result.success
4014 
    if result.ex is not None:
4015 
      raise result.ex
4016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4017 
 
4709 rajveer 4018 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4019 
    """
4020 
    Parameters:
4021 
     - cancelDateFrom
4022 
     - cancelDateTo
4023 
    """
4024 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4025 
    return self.recv_getCancelledOrders()
4026 
 
4027 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4028 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4029 
    args = getCancelledOrders_args()
4030 
    args.cancelDateFrom = cancelDateFrom
4031 
    args.cancelDateTo = cancelDateTo
4032 
    args.write(self._oprot)
4033 
    self._oprot.writeMessageEnd()
4034 
    self._oprot.trans.flush()
4035 
 
4036 
  def recv_getCancelledOrders(self, ):
4037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4038 
    if mtype == TMessageType.EXCEPTION:
4039 
      x = TApplicationException()
4040 
      x.read(self._iprot)
4041 
      self._iprot.readMessageEnd()
4042 
      raise x
4043 
    result = getCancelledOrders_result()
4044 
    result.read(self._iprot)
4045 
    self._iprot.readMessageEnd()
4046 
    if result.success is not None:
4047 
      return result.success
4048 
    if result.ex is not None:
4049 
      raise result.ex
4050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4051 
 
4600 varun.gupt 4052 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4053 
    """
4054 
    Parameters:
4055 
     - mapAWBAndAmount
4056 
    """
4057 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4058 
    self.recv_saveBluedartSettlements()
4059 
 
4060 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4061 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4062 
    args = saveBluedartSettlements_args()
4063 
    args.mapAWBAndAmount = mapAWBAndAmount
4064 
    args.write(self._oprot)
4065 
    self._oprot.writeMessageEnd()
4066 
    self._oprot.trans.flush()
4067 
 
4068 
  def recv_saveBluedartSettlements(self, ):
4069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4070 
    if mtype == TMessageType.EXCEPTION:
4071 
      x = TApplicationException()
4072 
      x.read(self._iprot)
4073 
      self._iprot.readMessageEnd()
4074 
      raise x
4075 
    result = saveBluedartSettlements_result()
4076 
    result.read(self._iprot)
4077 
    self._iprot.readMessageEnd()
4078 
    if result.ex is not None:
4079 
      raise result.ex
4080 
    return
4081 
 
4082 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4083 
    """
4084 
    Parameters:
4085 
     - settlementDate
4086 
     - paymentGatewayId
4087 
     - paymentId
4088 
     - serviceTax
4089 
     - otherCharges
4090 
     - netCollection
4091 
    """
4092 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4093 
    self.recv_savePaymentSettlements()
4094 
 
4095 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4096 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4097 
    args = savePaymentSettlements_args()
4098 
    args.settlementDate = settlementDate
4099 
    args.paymentGatewayId = paymentGatewayId
4100 
    args.paymentId = paymentId
4101 
    args.serviceTax = serviceTax
4102 
    args.otherCharges = otherCharges
4103 
    args.netCollection = netCollection
4104 
    args.write(self._oprot)
4105 
    self._oprot.writeMessageEnd()
4106 
    self._oprot.trans.flush()
4107 
 
4108 
  def recv_savePaymentSettlements(self, ):
4109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4110 
    if mtype == TMessageType.EXCEPTION:
4111 
      x = TApplicationException()
4112 
      x.read(self._iprot)
4113 
      self._iprot.readMessageEnd()
4114 
      raise x
4115 
    result = savePaymentSettlements_result()
4116 
    result.read(self._iprot)
4117 
    self._iprot.readMessageEnd()
4118 
    if result.ex is not None:
4119 
      raise result.ex
4120 
    return
4121 
 
4122 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4123 
    """
4124 
    Parameters:
4125 
     - settlementId
4126 
     - settlementDate
4127 
     - transactionDateFrom
4128 
     - transactionDateTo
4129 
     - amount
4130 
    """
4131 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4132 
    self.recv_saveEBSSettlementSummary()
4133 
 
4134 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4135 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4136 
    args = saveEBSSettlementSummary_args()
4137 
    args.settlementId = settlementId
4138 
    args.settlementDate = settlementDate
4139 
    args.transactionDateFrom = transactionDateFrom
4140 
    args.transactionDateTo = transactionDateTo
4141 
    args.amount = amount
4142 
    args.write(self._oprot)
4143 
    self._oprot.writeMessageEnd()
4144 
    self._oprot.trans.flush()
4145 
 
4146 
  def recv_saveEBSSettlementSummary(self, ):
4147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4148 
    if mtype == TMessageType.EXCEPTION:
4149 
      x = TApplicationException()
4150 
      x.read(self._iprot)
4151 
      self._iprot.readMessageEnd()
4152 
      raise x
4153 
    result = saveEBSSettlementSummary_result()
4154 
    result.read(self._iprot)
4155 
    self._iprot.readMessageEnd()
4156 
    if result.ex is not None:
4157 
      raise result.ex
4158 
    return
4159 
 
4160 
  def getSettlementForPaymentId(self, paymentId):
4161 
    """
4162 
    Parameters:
4163 
     - paymentId
4164 
    """
4165 
    self.send_getSettlementForPaymentId(paymentId)
4166 
    return self.recv_getSettlementForPaymentId()
4167 
 
4168 
  def send_getSettlementForPaymentId(self, paymentId):
4169 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4170 
    args = getSettlementForPaymentId_args()
4171 
    args.paymentId = paymentId
4172 
    args.write(self._oprot)
4173 
    self._oprot.writeMessageEnd()
4174 
    self._oprot.trans.flush()
4175 
 
4176 
  def recv_getSettlementForPaymentId(self, ):
4177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4178 
    if mtype == TMessageType.EXCEPTION:
4179 
      x = TApplicationException()
4180 
      x.read(self._iprot)
4181 
      self._iprot.readMessageEnd()
4182 
      raise x
4183 
    result = getSettlementForPaymentId_result()
4184 
    result.read(self._iprot)
4185 
    self._iprot.readMessageEnd()
4186 
    if result.success is not None:
4187 
      return result.success
4188 
    if result.ex is not None:
4189 
      raise result.ex
4190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4191 
 
4192 
  def getEBSSettlementSummaries(self, ):
4193 
    self.send_getEBSSettlementSummaries()
4194 
    return self.recv_getEBSSettlementSummaries()
4195 
 
4196 
  def send_getEBSSettlementSummaries(self, ):
4197 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4198 
    args = getEBSSettlementSummaries_args()
4199 
    args.write(self._oprot)
4200 
    self._oprot.writeMessageEnd()
4201 
    self._oprot.trans.flush()
4202 
 
4203 
  def recv_getEBSSettlementSummaries(self, ):
4204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4205 
    if mtype == TMessageType.EXCEPTION:
4206 
      x = TApplicationException()
4207 
      x.read(self._iprot)
4208 
      self._iprot.readMessageEnd()
4209 
      raise x
4210 
    result = getEBSSettlementSummaries_result()
4211 
    result.read(self._iprot)
4212 
    self._iprot.readMessageEnd()
4213 
    if result.success is not None:
4214 
      return result.success
4215 
    if result.ex is not None:
4216 
      raise result.ex
4217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4218 
 
4219 
  def markEBSSettlementUploaded(self, settlementId):
4220 
    """
4221 
    Parameters:
4222 
     - settlementId
4223 
    """
4224 
    self.send_markEBSSettlementUploaded(settlementId)
4225 
    self.recv_markEBSSettlementUploaded()
4226 
 
4227 
  def send_markEBSSettlementUploaded(self, settlementId):
4228 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4229 
    args = markEBSSettlementUploaded_args()
4230 
    args.settlementId = settlementId
4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_markEBSSettlementUploaded(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = markEBSSettlementUploaded_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.ex is not None:
4246 
      raise result.ex
4247 
    return
4248 
 
4249 
  def getEBSSettlementDate(self, settlementId):
4250 
    """
4251 
    Parameters:
4252 
     - settlementId
4253 
    """
4254 
    self.send_getEBSSettlementDate(settlementId)
4255 
    return self.recv_getEBSSettlementDate()
4256 
 
4257 
  def send_getEBSSettlementDate(self, settlementId):
4258 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4259 
    args = getEBSSettlementDate_args()
4260 
    args.settlementId = settlementId
4261 
    args.write(self._oprot)
4262 
    self._oprot.writeMessageEnd()
4263 
    self._oprot.trans.flush()
4264 
 
4265 
  def recv_getEBSSettlementDate(self, ):
4266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4267 
    if mtype == TMessageType.EXCEPTION:
4268 
      x = TApplicationException()
4269 
      x.read(self._iprot)
4270 
      self._iprot.readMessageEnd()
4271 
      raise x
4272 
    result = getEBSSettlementDate_result()
4273 
    result.read(self._iprot)
4274 
    self._iprot.readMessageEnd()
4275 
    if result.success is not None:
4276 
      return result.success
4277 
    if result.ex is not None:
4278 
      raise result.ex
4279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4280 
 
4281 
 
3376 rajveer 4282 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4283 
  def __init__(self, handler):
3376 rajveer 4284 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4285 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4286 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4287 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4288 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4289 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4290 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4291 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4292 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4293 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4294 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4295 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4296 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4297 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4298 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4299 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4300 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4301 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4302 
    self._processMap["createOrder"] = Processor.process_createOrder
4303 
    self._processMap["getOrder"] = Processor.process_getOrder
4304 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4305 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4306 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4307 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4308 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4309 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4310 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4311 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4312 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4313 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4314 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4315 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4316 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4317 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4318 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4319 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4320 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4321 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4322 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4323 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4324 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4325 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4326 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4327 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4328 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4329 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4330 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4331 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4332 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4333 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4334 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4335 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4336 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4337 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4338 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4339 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4340 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4341 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4342 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4343 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4344 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4345 
    self._processMap["changeItem"] = Processor.process_changeItem
4346 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4347 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4348 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4349 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4350 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4351 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4352 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4353 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4354 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4355 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4356 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4357 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4358 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4359 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4360 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4361 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4362 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4363 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4364 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4365 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4366 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4367 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4368 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4369 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4370 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4371 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4372 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4373 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4374 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4375 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4376 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4377 
 
4378 
  def process(self, iprot, oprot):
4379 
    (name, type, seqid) = iprot.readMessageBegin()
4380 
    if name not in self._processMap:
4381 
      iprot.skip(TType.STRUCT)
4382 
      iprot.readMessageEnd()
4383 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4384 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4385 
      x.write(oprot)
4386 
      oprot.writeMessageEnd()
4387 
      oprot.trans.flush()
4388 
      return
4389 
    else:
4390 
      self._processMap[name](self, seqid, iprot, oprot)
4391 
    return True
4392 
 
4393 
  def process_createTransaction(self, seqid, iprot, oprot):
4394 
    args = createTransaction_args()
4395 
    args.read(iprot)
4396 
    iprot.readMessageEnd()
4397 
    result = createTransaction_result()
4398 
    try:
132 ashish 4399 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4400 
    except TransactionServiceException, ex:
4401 
      result.ex = ex
4402 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
4407 
  def process_getTransaction(self, seqid, iprot, oprot):
4408 
    args = getTransaction_args()
4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
4411 
    result = getTransaction_result()
4412 
    try:
4413 
      result.success = self._handler.getTransaction(args.id)
4414 
    except TransactionServiceException, ex:
4415 
      result.ex = ex
4416 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
4420 
 
4421 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4422 
    args = getTransactionsForCustomer_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    result = getTransactionsForCustomer_result()
4426 
    try:
4427 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4428 
    except TransactionServiceException, ex:
4429 
      result.ex = ex
4430 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
132 ashish 4435 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4436 
    args = getTransactionsForShoppingCartId_args()
4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
4439 
    result = getTransactionsForShoppingCartId_result()
4440 
    try:
4441 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4442 
    except TransactionServiceException, ex:
4443 
      result.ex = ex
4444 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
4448 
 
94 ashish 4449 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4450 
    args = getTransactionStatus_args()
4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
4453 
    result = getTransactionStatus_result()
4454 
    try:
4455 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4456 
    except TransactionServiceException, ex:
4457 
      result.ex = ex
4458 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
4463 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4464 
    args = changeTransactionStatus_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = changeTransactionStatus_result()
4468 
    try:
4469 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4470 
    except TransactionServiceException, ex:
4471 
      result.ex = ex
4472 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
1398 varun.gupt 4477 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4478 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
1398 varun.gupt 4481 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4482 
    try:
1398 varun.gupt 4483 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4484 
    except TransactionServiceException, ex:
4485 
      result.ex = ex
1398 varun.gupt 4486 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4487 
    result.write(oprot)
4488 
    oprot.writeMessageEnd()
4489 
    oprot.trans.flush()
4490 
 
483 rajveer 4491 
  def process_getAllOrders(self, seqid, iprot, oprot):
4492 
    args = getAllOrders_args()
94 ashish 4493 
    args.read(iprot)
4494 
    iprot.readMessageEnd()
483 rajveer 4495 
    result = getAllOrders_result()
94 ashish 4496 
    try:
483 rajveer 4497 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4498 
    except TransactionServiceException, ex:
4499 
      result.ex = ex
483 rajveer 4500 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
4133 chandransh 4505 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4506 
    args = getOrdersInBatch_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = getOrdersInBatch_result()
4510 
    try:
4511 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4512 
    except TransactionServiceException, ex:
4513 
      result.ex = ex
4514 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4515 
    result.write(oprot)
4516 
    oprot.writeMessageEnd()
4517 
    oprot.trans.flush()
4518 
 
4519 
  def process_getOrderCount(self, seqid, iprot, oprot):
4520 
    args = getOrderCount_args()
4521 
    args.read(iprot)
4522 
    iprot.readMessageEnd()
4523 
    result = getOrderCount_result()
4524 
    try:
4525 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4526 
    except TransactionServiceException, ex:
4527 
      result.ex = ex
4528 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4529 
    result.write(oprot)
4530 
    oprot.writeMessageEnd()
4531 
    oprot.trans.flush()
4532 
 
999 varun.gupt 4533 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4534 
    args = getOrdersByBillingDate_args()
4535 
    args.read(iprot)
4536 
    iprot.readMessageEnd()
4537 
    result = getOrdersByBillingDate_result()
4538 
    try:
4539 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4540 
    except TransactionServiceException, ex:
4541 
      result.ex = ex
4542 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4543 
    result.write(oprot)
4544 
    oprot.writeMessageEnd()
4545 
    oprot.trans.flush()
4546 
 
3427 chandransh 4547 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4548 
    args = getOrdersByShippingDate_args()
4549 
    args.read(iprot)
4550 
    iprot.readMessageEnd()
4551 
    result = getOrdersByShippingDate_result()
4552 
    try:
3451 chandransh 4553 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4554 
    except TransactionServiceException, ex:
4555 
      result.ex = ex
4556 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4557 
    result.write(oprot)
4558 
    oprot.writeMessageEnd()
4559 
    oprot.trans.flush()
4560 
 
1382 varun.gupt 4561 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4562 
    args = getReturnableOrdersForCustomer_args()
4563 
    args.read(iprot)
4564 
    iprot.readMessageEnd()
4565 
    result = getReturnableOrdersForCustomer_result()
4566 
    try:
4567 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4568 
    except TransactionServiceException, ex:
4569 
      result.ex = ex
4570 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
4575 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4576 
    args = getCancellableOrdersForCustomer_args()
4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
4579 
    result = getCancellableOrdersForCustomer_result()
4580 
    try:
4581 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4582 
    except TransactionServiceException, ex:
4583 
      result.ex = ex
4584 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4585 
    result.write(oprot)
4586 
    oprot.writeMessageEnd()
4587 
    oprot.trans.flush()
4588 
 
483 rajveer 4589 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4590 
    args = changeOrderStatus_args()
94 ashish 4591 
    args.read(iprot)
4592 
    iprot.readMessageEnd()
483 rajveer 4593 
    result = changeOrderStatus_result()
94 ashish 4594 
    try:
483 rajveer 4595 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4596 
    except TransactionServiceException, ex:
4597 
      result.ex = ex
483 rajveer 4598 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4599 
    result.write(oprot)
4600 
    oprot.writeMessageEnd()
4601 
    oprot.trans.flush()
4602 
 
483 rajveer 4603 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4604 
    args = getOrdersForTransaction_args()
94 ashish 4605 
    args.read(iprot)
4606 
    iprot.readMessageEnd()
483 rajveer 4607 
    result = getOrdersForTransaction_result()
94 ashish 4608 
    try:
1528 ankur.sing 4609 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4610 
    except TransactionServiceException, ex:
4611 
      result.ex = ex
483 rajveer 4612 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4613 
    result.write(oprot)
4614 
    oprot.writeMessageEnd()
4615 
    oprot.trans.flush()
4616 
 
483 rajveer 4617 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4618 
    args = getOrdersForCustomer_args()
94 ashish 4619 
    args.read(iprot)
4620 
    iprot.readMessageEnd()
483 rajveer 4621 
    result = getOrdersForCustomer_result()
94 ashish 4622 
    try:
3014 chandransh 4623 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4624 
    except TransactionServiceException, ex:
4625 
      result.ex = ex
483 rajveer 4626 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4627 
    result.write(oprot)
4628 
    oprot.writeMessageEnd()
4629 
    oprot.trans.flush()
4630 
 
483 rajveer 4631 
  def process_createOrder(self, seqid, iprot, oprot):
4632 
    args = createOrder_args()
94 ashish 4633 
    args.read(iprot)
4634 
    iprot.readMessageEnd()
483 rajveer 4635 
    result = createOrder_result()
94 ashish 4636 
    try:
483 rajveer 4637 
      result.success = self._handler.createOrder(args.order)
94 ashish 4638 
    except TransactionServiceException, ex:
4639 
      result.ex = ex
483 rajveer 4640 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4641 
    result.write(oprot)
4642 
    oprot.writeMessageEnd()
4643 
    oprot.trans.flush()
4644 
 
483 rajveer 4645 
  def process_getOrder(self, seqid, iprot, oprot):
4646 
    args = getOrder_args()
94 ashish 4647 
    args.read(iprot)
4648 
    iprot.readMessageEnd()
483 rajveer 4649 
    result = getOrder_result()
94 ashish 4650 
    try:
483 rajveer 4651 
      result.success = self._handler.getOrder(args.id)
94 ashish 4652 
    except TransactionServiceException, ex:
4653 
      result.ex = ex
483 rajveer 4654 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4655 
    result.write(oprot)
4656 
    oprot.writeMessageEnd()
4657 
    oprot.trans.flush()
4658 
 
483 rajveer 4659 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4660 
    args = getLineItemsForOrder_args()
94 ashish 4661 
    args.read(iprot)
4662 
    iprot.readMessageEnd()
483 rajveer 4663 
    result = getLineItemsForOrder_result()
94 ashish 4664 
    try:
483 rajveer 4665 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4666 
    except TransactionServiceException, ex:
4667 
      result.ex = ex
483 rajveer 4668 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4669 
    result.write(oprot)
4670 
    oprot.writeMessageEnd()
4671 
    oprot.trans.flush()
4672 
 
1528 ankur.sing 4673 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4674 
    args = getOrderForCustomer_args()
4675 
    args.read(iprot)
4676 
    iprot.readMessageEnd()
4677 
    result = getOrderForCustomer_result()
4678 
    try:
4679 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4680 
    except TransactionServiceException, ex:
4681 
      result.ex = ex
4682 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
3064 chandransh 4687 
  def process_getAlerts(self, seqid, iprot, oprot):
4688 
    args = getAlerts_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = getAlerts_result()
4444 rajveer 4692 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4693 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
4394 rajveer 4698 
  def process_addAlert(self, seqid, iprot, oprot):
4699 
    args = addAlert_args()
3064 chandransh 4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4394 rajveer 4702 
    result = addAlert_result()
4444 rajveer 4703 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4704 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4444 rajveer 4709 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4710 
    args = markAlertsAsSeen_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = markAlertsAsSeen_result()
4714 
    self._handler.markAlertsAsSeen(args.warehouseId)
4715 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
3064 chandransh 4720 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4721 
    args = getValidOrderCount_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getValidOrderCount_result()
4725 
    result.success = self._handler.getValidOrderCount()
4726 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
4731 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4732 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4736 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4737 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
4742 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4743 
    args = getValidOrdersAmountRange_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = getValidOrdersAmountRange_result()
4747 
    result.success = self._handler.getValidOrdersAmountRange()
4748 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
4753 
  def process_getValidOrders(self, seqid, iprot, oprot):
4754 
    args = getValidOrders_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = getValidOrders_result()
4758 
    result.success = self._handler.getValidOrders(args.limit)
4759 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
1220 chandransh 4764 
  def process_batchOrders(self, seqid, iprot, oprot):
4765 
    args = batchOrders_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = batchOrders_result()
4769 
    try:
4770 
      result.success = self._handler.batchOrders(args.warehouseId)
4771 
    except TransactionServiceException, ex:
4772 
      result.ex = ex
4773 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4777 
 
1208 chandransh 4778 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4779 
    args = markOrderAsOutOfStock_args()
4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
4782 
    result = markOrderAsOutOfStock_result()
4783 
    try:
4784 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4785 
    except TransactionServiceException, ex:
4786 
      result.ex = ex
4787 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
3064 chandransh 4792 
  def process_verifyOrder(self, seqid, iprot, oprot):
4793 
    args = verifyOrder_args()
759 chandransh 4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
3064 chandransh 4796 
    result = verifyOrder_result()
759 chandransh 4797 
    try:
3064 chandransh 4798 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4799 
    except TransactionServiceException, ex:
4800 
      result.ex = ex
3064 chandransh 4801 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
3064 chandransh 4806 
  def process_acceptOrder(self, seqid, iprot, oprot):
4807 
    args = acceptOrder_args()
1113 chandransh 4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
3064 chandransh 4810 
    result = acceptOrder_result()
1113 chandransh 4811 
    try:
3064 chandransh 4812 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4813 
    except TransactionServiceException, ex:
4814 
      result.ex = ex
3064 chandransh 4815 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
4819 
 
3064 chandransh 4820 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4821 
    args = addBillingDetails_args()
1135 chandransh 4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
3064 chandransh 4824 
    result = addBillingDetails_result()
1135 chandransh 4825 
    try:
4658 mandeep.dh 4826 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4827 
    except TransactionServiceException, ex:
4828 
      result.ex = ex
3064 chandransh 4829 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4833 
 
4579 rajveer 4834 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4835 
    args = addInvoiceNumber_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = addInvoiceNumber_result()
4839 
    try:
4840 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4841 
    except TransactionServiceException, ex:
4842 
      result.ex = ex
4843 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4844 
    result.write(oprot)
4845 
    oprot.writeMessageEnd()
4846 
    oprot.trans.flush()
4847 
 
3064 chandransh 4848 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4849 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4850 
    args.read(iprot)
4851 
    iprot.readMessageEnd()
3064 chandransh 4852 
    result = markOrdersAsManifested_result()
4853 
    try:
4854 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4855 
    except TransactionServiceException, ex:
4856 
      result.ex = ex
4857 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4858 
    result.write(oprot)
4859 
    oprot.writeMessageEnd()
4860 
    oprot.trans.flush()
4861 
 
4410 rajveer 4862 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4863 
    args = markOrdersAsShippedFromWarehouse_args()
4864 
    args.read(iprot)
4865 
    iprot.readMessageEnd()
4866 
    result = markOrdersAsShippedFromWarehouse_result()
4867 
    try:
4868 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4869 
    except TransactionServiceException, ex:
4870 
      result.ex = ex
4871 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
3064 chandransh 4876 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4877 
    args = markOrdersAsPickedUp_args()
304 ashish 4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
3064 chandransh 4880 
    result = markOrdersAsPickedUp_result()
4881 
    try:
4882 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4883 
    except TransactionServiceException, ex:
4884 
      result.ex = ex
4885 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4886 
    result.write(oprot)
4887 
    oprot.writeMessageEnd()
4888 
    oprot.trans.flush()
94 ashish 4889 
 
3064 chandransh 4890 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4891 
    args = markOrdersAsDelivered_args()
304 ashish 4892 
    args.read(iprot)
4893 
    iprot.readMessageEnd()
3064 chandransh 4894 
    result = markOrdersAsDelivered_result()
4895 
    try:
4896 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4897 
    except TransactionServiceException, ex:
4898 
      result.ex = ex
4899 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4900 
    result.write(oprot)
4901 
    oprot.writeMessageEnd()
4902 
    oprot.trans.flush()
4903 
 
3064 chandransh 4904 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4905 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4906 
    args.read(iprot)
4907 
    iprot.readMessageEnd()
3064 chandransh 4908 
    result = markOrdersAsFailed_result()
4909 
    try:
4910 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4911 
    except TransactionServiceException, ex:
4912 
      result.ex = ex
4913 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
304 ashish 4917 
 
3064 chandransh 4918 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4919 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
3064 chandransh 4922 
    result = updateNonDeliveryReason_result()
4923 
    try:
4581 phani.kuma 4924 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4925 
    except TransactionServiceException, ex:
4926 
      result.ex = ex
4927 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
1596 ankur.sing 4931 
 
3064 chandransh 4932 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4933 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
3064 chandransh 4936 
    result = getUndeliveredOrders_result()
4937 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4938 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
4942 
 
2536 chandransh 4943 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4944 
    args = toggleDOAFlag_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = toggleDOAFlag_result()
4948 
    try:
4949 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4950 
    except TransactionServiceException, ex:
4951 
      result.ex = ex
4952 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
1886 ankur.sing 4956 
 
4712 rajveer 4957 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
4958 
    args = markOrderAsDelivered_args()
4959 
    args.read(iprot)
4960 
    iprot.readMessageEnd()
4961 
    result = markOrderAsDelivered_result()
4962 
    try:
4963 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
4964 
    except TransactionServiceException, ex:
4965 
      result.ex = ex
4966 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
4970 
 
4454 rajveer 4971 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4972 
    args = markOrderDoaRequestReceived_args()
4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
4975 
    result = markOrderDoaRequestReceived_result()
4976 
    try:
4977 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4978 
    except TransactionServiceException, ex:
4979 
      result.ex = ex
4980 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
4984 
 
4985 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4986 
    args = markOrderDoaRequestAuthorized_args()
4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
4989 
    result = markOrderDoaRequestAuthorized_result()
4990 
    try:
4991 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4992 
    except TransactionServiceException, ex:
4993 
      result.ex = ex
4994 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4995 
    result.write(oprot)
4996 
    oprot.writeMessageEnd()
4997 
    oprot.trans.flush()
4998 
 
4488 rajveer 4999 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5000 
    args = markOrderReturnRequestReceived_args()
5001 
    args.read(iprot)
5002 
    iprot.readMessageEnd()
5003 
    result = markOrderReturnRequestReceived_result()
5004 
    try:
5005 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5006 
    except TransactionServiceException, ex:
5007 
      result.ex = ex
5008 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5009 
    result.write(oprot)
5010 
    oprot.writeMessageEnd()
5011 
    oprot.trans.flush()
5012 
 
5013 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5014 
    args = markOrderReturnRequestAuthorized_args()
5015 
    args.read(iprot)
5016 
    iprot.readMessageEnd()
5017 
    result = markOrderReturnRequestAuthorized_result()
5018 
    try:
5019 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5020 
    except TransactionServiceException, ex:
5021 
      result.ex = ex
5022 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5023 
    result.write(oprot)
5024 
    oprot.writeMessageEnd()
5025 
    oprot.trans.flush()
5026 
 
2536 chandransh 5027 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5028 
    args = requestPickupNumber_args()
5029 
    args.read(iprot)
5030 
    iprot.readMessageEnd()
5031 
    result = requestPickupNumber_result()
5032 
    try:
4579 rajveer 5033 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5034 
    except TransactionServiceException, ex:
5035 
      result.ex = ex
5036 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
5040 
 
5041 
  def process_authorizePickup(self, seqid, iprot, oprot):
5042 
    args = authorizePickup_args()
5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
5045 
    result = authorizePickup_result()
5046 
    try:
4602 rajveer 5047 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5048 
    except TransactionServiceException, ex:
5049 
      result.ex = ex
5050 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5051 
    result.write(oprot)
5052 
    oprot.writeMessageEnd()
5053 
    oprot.trans.flush()
5054 
 
2764 chandransh 5055 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5056 
    args = markDoasAsPickedUp_args()
5057 
    args.read(iprot)
5058 
    iprot.readMessageEnd()
5059 
    result = markDoasAsPickedUp_result()
5060 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5061 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5062 
    result.write(oprot)
5063 
    oprot.writeMessageEnd()
5064 
    oprot.trans.flush()
5065 
 
2616 chandransh 5066 
  def process_receiveReturn(self, seqid, iprot, oprot):
5067 
    args = receiveReturn_args()
2591 chandransh 5068 
    args.read(iprot)
5069 
    iprot.readMessageEnd()
2616 chandransh 5070 
    result = receiveReturn_result()
2591 chandransh 5071 
    try:
4479 rajveer 5072 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5073 
    except TransactionServiceException, ex:
5074 
      result.ex = ex
2616 chandransh 5075 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
2536 chandransh 5079 
 
2591 chandransh 5080 
  def process_validateDoa(self, seqid, iprot, oprot):
5081 
    args = validateDoa_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = validateDoa_result()
5085 
    try:
5086 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5087 
    except TransactionServiceException, ex:
5088 
      result.ex = ex
5089 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5090 
    result.write(oprot)
5091 
    oprot.writeMessageEnd()
5092 
    oprot.trans.flush()
5093 
 
4495 rajveer 5094 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5095 
    args = validateReturnProduct_args()
5096 
    args.read(iprot)
5097 
    iprot.readMessageEnd()
5098 
    result = validateReturnProduct_result()
5099 
    try:
5100 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5101 
    except TransactionServiceException, ex:
5102 
      result.ex = ex
5103 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
2616 chandransh 5108 
  def process_reshipOrder(self, seqid, iprot, oprot):
5109 
    args = reshipOrder_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = reshipOrder_result()
5113 
    try:
5114 
      result.success = self._handler.reshipOrder(args.orderId)
5115 
    except TransactionServiceException, ex:
5116 
      result.ex = ex
5117 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
2591 chandransh 5121 
 
2616 chandransh 5122 
  def process_refundOrder(self, seqid, iprot, oprot):
5123 
    args = refundOrder_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = refundOrder_result()
5127 
    try:
3226 chandransh 5128 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5129 
    except TransactionServiceException, ex:
5130 
      result.ex = ex
5131 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5132 
    result.write(oprot)
5133 
    oprot.writeMessageEnd()
5134 
    oprot.trans.flush()
5135 
 
2690 chandransh 5136 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5137 
    args = getReturnOrders_args()
5138 
    args.read(iprot)
5139 
    iprot.readMessageEnd()
5140 
    result = getReturnOrders_result()
5141 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5142 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5143 
    result.write(oprot)
5144 
    oprot.writeMessageEnd()
5145 
    oprot.trans.flush()
2616 chandransh 5146 
 
2700 chandransh 5147 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5148 
    args = getReturnOrder_args()
5149 
    args.read(iprot)
5150 
    iprot.readMessageEnd()
5151 
    result = getReturnOrder_result()
5152 
    try:
5153 
      result.success = self._handler.getReturnOrder(args.id)
5154 
    except TransactionServiceException, ex:
5155 
      result.ex = ex
5156 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5157 
    result.write(oprot)
5158 
    oprot.writeMessageEnd()
5159 
    oprot.trans.flush()
5160 
 
2690 chandransh 5161 
  def process_processReturn(self, seqid, iprot, oprot):
5162 
    args = processReturn_args()
5163 
    args.read(iprot)
5164 
    iprot.readMessageEnd()
5165 
    result = processReturn_result()
5166 
    try:
5167 
      self._handler.processReturn(args.returnOrderId)
5168 
    except TransactionServiceException, ex:
5169 
      result.ex = ex
5170 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5171 
    result.write(oprot)
5172 
    oprot.writeMessageEnd()
5173 
    oprot.trans.flush()
5174 
 
2819 chandransh 5175 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5176 
    args = createPurchaseOrder_args()
5177 
    args.read(iprot)
5178 
    iprot.readMessageEnd()
5179 
    result = createPurchaseOrder_result()
5180 
    try:
5181 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5182 
    except TransactionServiceException, ex:
5183 
      result.ex = ex
5184 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5185 
    result.write(oprot)
5186 
    oprot.writeMessageEnd()
5187 
    oprot.trans.flush()
2690 chandransh 5188 
 
3451 chandransh 5189 
  def process_updateWeight(self, seqid, iprot, oprot):
5190 
    args = updateWeight_args()
5191 
    args.read(iprot)
5192 
    iprot.readMessageEnd()
5193 
    result = updateWeight_result()
5194 
    try:
5195 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5196 
    except TransactionServiceException, ex:
5197 
      result.ex = ex
5198 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5199 
    result.write(oprot)
5200 
    oprot.writeMessageEnd()
5201 
    oprot.trans.flush()
2819 chandransh 5202 
 
3469 chandransh 5203 
  def process_changeItem(self, seqid, iprot, oprot):
5204 
    args = changeItem_args()
5205 
    args.read(iprot)
5206 
    iprot.readMessageEnd()
5207 
    result = changeItem_result()
5208 
    try:
5209 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5210 
    except TransactionServiceException, ex:
5211 
      result.ex = ex
5212 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5213 
    result.write(oprot)
5214 
    oprot.writeMessageEnd()
5215 
    oprot.trans.flush()
3451 chandransh 5216 
 
3469 chandransh 5217 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5218 
    args = shiftToWarehouse_args()
5219 
    args.read(iprot)
5220 
    iprot.readMessageEnd()
5221 
    result = shiftToWarehouse_result()
5222 
    try:
5223 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5224 
    except TransactionServiceException, ex:
5225 
      result.ex = ex
5226 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5227 
    result.write(oprot)
5228 
    oprot.writeMessageEnd()
5229 
    oprot.trans.flush()
5230 
 
3553 chandransh 5231 
  def process_addDelayReason(self, seqid, iprot, oprot):
5232 
    args = addDelayReason_args()
5233 
    args.read(iprot)
5234 
    iprot.readMessageEnd()
5235 
    result = addDelayReason_result()
5236 
    try:
4647 rajveer 5237 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5238 
    except TransactionServiceException, ex:
5239 
      result.ex = ex
5240 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5241 
    result.write(oprot)
5242 
    oprot.writeMessageEnd()
5243 
    oprot.trans.flush()
3469 chandransh 5244 
 
3956 chandransh 5245 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5246 
    args = reconcileCodCollection_args()
5247 
    args.read(iprot)
5248 
    iprot.readMessageEnd()
5249 
    result = reconcileCodCollection_result()
5250 
    try:
5251 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5252 
    except TransactionServiceException, ex:
5253 
      result.ex = ex
5254 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
3553 chandransh 5258 
 
4008 mandeep.dh 5259 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5260 
    args = getTransactionsRequiringExtraProcessing_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = getTransactionsRequiringExtraProcessing_result()
5264 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5265 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
3956 chandransh 5269 
 
4008 mandeep.dh 5270 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5271 
    args = markTransactionAsProcessed_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = markTransactionAsProcessed_result()
5275 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5276 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
4018 chandransh 5281 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5282 
    args = getItemWiseRiskyOrdersCount_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = getItemWiseRiskyOrdersCount_result()
5286 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5287 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
4008 mandeep.dh 5291 
 
4295 varun.gupt 5292 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5293 
    args = getOrdersForItemIds_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getOrdersForItemIds_result()
5297 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5298 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
4247 rajveer 5303 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5304 
    args = markOrderCancellationRequestReceived_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = markOrderCancellationRequestReceived_result()
5308 
    try:
5309 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
5312 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
4018 chandransh 5316 
 
4247 rajveer 5317 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5318 
    args = markOrderCancellationRequestConfirmed_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = markOrderCancellationRequestConfirmed_result()
5322 
    try:
5323 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
5326 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
5330 
 
5331 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5332 
    args = markOrderCancellationRequestDenied_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = markOrderCancellationRequestDenied_result()
5336 
    try:
5337 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
5340 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
4258 rajveer 5345 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5346 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
4258 rajveer 5349 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5350 
    try:
4258 rajveer 5351 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5352 
    except TransactionServiceException, ex:
5353 
      result.ex = ex
4258 rajveer 5354 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
5358 
 
4259 anupam.sin 5359 
  def process_refundTransaction(self, seqid, iprot, oprot):
5360 
    args = refundTransaction_args()
5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
5363 
    result = refundTransaction_result()
5364 
    try:
5365 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
5368 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
4247 rajveer 5372 
 
4324 mandeep.dh 5373 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5374 
    args = updateShipmentAddress_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = updateShipmentAddress_result()
5378 
    try:
5379 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
5382 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
4285 rajveer 5387 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5388 
    args = acceptOrdersForItemId_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = acceptOrdersForItemId_result()
5392 
    try:
5393 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5394 
    except TransactionServiceException, ex:
5395 
      result.ex = ex
5396 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
4259 anupam.sin 5400 
 
4303 rajveer 5401 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5402 
    args = markOrdersAsPORaised_args()
5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
5405 
    result = markOrdersAsPORaised_result()
5406 
    try:
4369 rajveer 5407 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5408 
    except TransactionServiceException, ex:
5409 
      result.ex = ex
5410 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
4285 rajveer 5414 
 
4303 rajveer 5415 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5416 
    args = markOrdersAsReversalInitiated_args()
5417 
    args.read(iprot)
5418 
    iprot.readMessageEnd()
5419 
    result = markOrdersAsReversalInitiated_result()
5420 
    try:
4369 rajveer 5421 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5422 
    except TransactionServiceException, ex:
5423 
      result.ex = ex
5424 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5425 
    result.write(oprot)
5426 
    oprot.writeMessageEnd()
5427 
    oprot.trans.flush()
5428 
 
5429 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5430 
    args = markOrdersAsNotAvailabke_args()
5431 
    args.read(iprot)
5432 
    iprot.readMessageEnd()
5433 
    result = markOrdersAsNotAvailabke_result()
5434 
    try:
4369 rajveer 5435 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5436 
    except TransactionServiceException, ex:
5437 
      result.ex = ex
5438 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5439 
    result.write(oprot)
5440 
    oprot.writeMessageEnd()
5441 
    oprot.trans.flush()
5442 
 
4369 rajveer 5443 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5444 
    args = markOrdersAsTimeout_args()
5445 
    args.read(iprot)
5446 
    iprot.readMessageEnd()
5447 
    result = markOrdersAsTimeout_result()
5448 
    try:
5449 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5450 
    except TransactionServiceException, ex:
5451 
      result.ex = ex
5452 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5453 
    result.write(oprot)
5454 
    oprot.writeMessageEnd()
5455 
    oprot.trans.flush()
4303 rajveer 5456 
 
4662 rajveer 5457 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5458 
    args = markOrderAsLostInTransit_args()
5459 
    args.read(iprot)
5460 
    iprot.readMessageEnd()
5461 
    result = markOrderAsLostInTransit_result()
5462 
    try:
5463 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5464 
    except TransactionServiceException, ex:
5465 
      result.ex = ex
5466 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5467 
    result.write(oprot)
5468 
    oprot.writeMessageEnd()
5469 
    oprot.trans.flush()
5470 
 
4386 anupam.sin 5471 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5472 
    args = getOrderForAwb_args()
5473 
    args.read(iprot)
5474 
    iprot.readMessageEnd()
5475 
    result = getOrderForAwb_result()
5476 
    try:
5477 
      result.success = self._handler.getOrderForAwb(args.awb)
5478 
    except TransactionServiceException, ex:
5479 
      result.ex = ex
5480 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5481 
    result.write(oprot)
5482 
    oprot.writeMessageEnd()
5483 
    oprot.trans.flush()
4369 rajveer 5484 
 
4506 phani.kuma 5485 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5486 
    args = getOrdersForProviderForStatus_args()
5487 
    args.read(iprot)
5488 
    iprot.readMessageEnd()
5489 
    result = getOrdersForProviderForStatus_result()
5490 
    try:
5491 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5492 
    except TransactionServiceException, ex:
5493 
      result.ex = ex
5494 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5495 
    result.write(oprot)
5496 
    oprot.writeMessageEnd()
5497 
    oprot.trans.flush()
4386 anupam.sin 5498 
 
4600 varun.gupt 5499 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5500 
    args = getBilledOrdersForVendor_args()
5501 
    args.read(iprot)
5502 
    iprot.readMessageEnd()
5503 
    result = getBilledOrdersForVendor_result()
5504 
    try:
5505 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5506 
    except TransactionServiceException, ex:
5507 
      result.ex = ex
5508 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5509 
    result.write(oprot)
5510 
    oprot.writeMessageEnd()
5511 
    oprot.trans.flush()
4506 phani.kuma 5512 
 
4607 rajveer 5513 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5514 
    args = getSlippedSippingDateOrders_args()
5515 
    args.read(iprot)
5516 
    iprot.readMessageEnd()
5517 
    result = getSlippedSippingDateOrders_result()
5518 
    try:
5519 
      result.success = self._handler.getSlippedSippingDateOrders()
5520 
    except TransactionServiceException, ex:
5521 
      result.ex = ex
5522 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5523 
    result.write(oprot)
5524 
    oprot.writeMessageEnd()
5525 
    oprot.trans.flush()
5526 
 
4709 rajveer 5527 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5528 
    args = getCancelledOrders_args()
5529 
    args.read(iprot)
5530 
    iprot.readMessageEnd()
5531 
    result = getCancelledOrders_result()
5532 
    try:
5533 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5534 
    except TransactionServiceException, ex:
5535 
      result.ex = ex
5536 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5537 
    result.write(oprot)
5538 
    oprot.writeMessageEnd()
5539 
    oprot.trans.flush()
5540 
 
4600 varun.gupt 5541 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5542 
    args = saveBluedartSettlements_args()
5543 
    args.read(iprot)
5544 
    iprot.readMessageEnd()
5545 
    result = saveBluedartSettlements_result()
5546 
    try:
5547 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5548 
    except TransactionServiceException, ex:
5549 
      result.ex = ex
5550 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5551 
    result.write(oprot)
5552 
    oprot.writeMessageEnd()
5553 
    oprot.trans.flush()
5554 
 
5555 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5556 
    args = savePaymentSettlements_args()
5557 
    args.read(iprot)
5558 
    iprot.readMessageEnd()
5559 
    result = savePaymentSettlements_result()
5560 
    try:
5561 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5562 
    except TransactionServiceException, ex:
5563 
      result.ex = ex
5564 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5565 
    result.write(oprot)
5566 
    oprot.writeMessageEnd()
5567 
    oprot.trans.flush()
5568 
 
5569 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5570 
    args = saveEBSSettlementSummary_args()
5571 
    args.read(iprot)
5572 
    iprot.readMessageEnd()
5573 
    result = saveEBSSettlementSummary_result()
5574 
    try:
5575 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5576 
    except TransactionServiceException, ex:
5577 
      result.ex = ex
5578 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5579 
    result.write(oprot)
5580 
    oprot.writeMessageEnd()
5581 
    oprot.trans.flush()
5582 
 
5583 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5584 
    args = getSettlementForPaymentId_args()
5585 
    args.read(iprot)
5586 
    iprot.readMessageEnd()
5587 
    result = getSettlementForPaymentId_result()
5588 
    try:
5589 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5590 
    except TransactionServiceException, ex:
5591 
      result.ex = ex
5592 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5593 
    result.write(oprot)
5594 
    oprot.writeMessageEnd()
5595 
    oprot.trans.flush()
5596 
 
5597 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5598 
    args = getEBSSettlementSummaries_args()
5599 
    args.read(iprot)
5600 
    iprot.readMessageEnd()
5601 
    result = getEBSSettlementSummaries_result()
5602 
    try:
5603 
      result.success = self._handler.getEBSSettlementSummaries()
5604 
    except TransactionServiceException, ex:
5605 
      result.ex = ex
5606 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5607 
    result.write(oprot)
5608 
    oprot.writeMessageEnd()
5609 
    oprot.trans.flush()
5610 
 
5611 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5612 
    args = markEBSSettlementUploaded_args()
5613 
    args.read(iprot)
5614 
    iprot.readMessageEnd()
5615 
    result = markEBSSettlementUploaded_result()
5616 
    try:
5617 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5618 
    except TransactionServiceException, ex:
5619 
      result.ex = ex
5620 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5621 
    result.write(oprot)
5622 
    oprot.writeMessageEnd()
5623 
    oprot.trans.flush()
5624 
 
5625 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5626 
    args = getEBSSettlementDate_args()
5627 
    args.read(iprot)
5628 
    iprot.readMessageEnd()
5629 
    result = getEBSSettlementDate_result()
5630 
    try:
5631 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5632 
    except TransactionServiceException, ex:
5633 
      result.ex = ex
5634 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5635 
    result.write(oprot)
5636 
    oprot.writeMessageEnd()
5637 
    oprot.trans.flush()
5638 
 
5639 
 
94 ashish 5640 
# HELPER FUNCTIONS AND STRUCTURES
5641 
 
5642 
class createTransaction_args:
5643 
  """
5644 
  Attributes:
5645 
   - transaction
5646 
  """
5647 
 
5648 
  thrift_spec = (
5649 
    None, # 0
5650 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5651 
  )
5652 
 
5653 
  def __init__(self, transaction=None,):
5654 
    self.transaction = transaction
5655 
 
5656 
  def read(self, iprot):
5657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5659 
      return
5660 
    iprot.readStructBegin()
5661 
    while True:
5662 
      (fname, ftype, fid) = iprot.readFieldBegin()
5663 
      if ftype == TType.STOP:
5664 
        break
5665 
      if fid == 1:
5666 
        if ftype == TType.STRUCT:
5667 
          self.transaction = Transaction()
5668 
          self.transaction.read(iprot)
5669 
        else:
5670 
          iprot.skip(ftype)
5671 
      else:
5672 
        iprot.skip(ftype)
5673 
      iprot.readFieldEnd()
5674 
    iprot.readStructEnd()
5675 
 
5676 
  def write(self, oprot):
5677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5679 
      return
5680 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5681 
    if self.transaction is not None:
94 ashish 5682 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5683 
      self.transaction.write(oprot)
5684 
      oprot.writeFieldEnd()
5685 
    oprot.writeFieldStop()
5686 
    oprot.writeStructEnd()
5687 
 
3431 rajveer 5688 
  def validate(self):
5689 
    return
5690 
 
5691 
 
94 ashish 5692 
  def __repr__(self):
5693 
    L = ['%s=%r' % (key, value)
5694 
      for key, value in self.__dict__.iteritems()]
5695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5696 
 
5697 
  def __eq__(self, other):
5698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5699 
 
5700 
  def __ne__(self, other):
5701 
    return not (self == other)
5702 
 
5703 
class createTransaction_result:
5704 
  """
5705 
  Attributes:
132 ashish 5706 
   - success
94 ashish 5707 
   - ex
5708 
  """
5709 
 
5710 
  thrift_spec = (
132 ashish 5711 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5713 
  )
5714 
 
132 ashish 5715 
  def __init__(self, success=None, ex=None,):
5716 
    self.success = success
94 ashish 5717 
    self.ex = ex
5718 
 
5719 
  def read(self, iprot):
5720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5722 
      return
5723 
    iprot.readStructBegin()
5724 
    while True:
5725 
      (fname, ftype, fid) = iprot.readFieldBegin()
5726 
      if ftype == TType.STOP:
5727 
        break
132 ashish 5728 
      if fid == 0:
5729 
        if ftype == TType.I64:
5730 
          self.success = iprot.readI64();
5731 
        else:
5732 
          iprot.skip(ftype)
5733 
      elif fid == 1:
94 ashish 5734 
        if ftype == TType.STRUCT:
5735 
          self.ex = TransactionServiceException()
5736 
          self.ex.read(iprot)
5737 
        else:
5738 
          iprot.skip(ftype)
5739 
      else:
5740 
        iprot.skip(ftype)
5741 
      iprot.readFieldEnd()
5742 
    iprot.readStructEnd()
5743 
 
5744 
  def write(self, oprot):
5745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5747 
      return
5748 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5749 
    if self.success is not None:
132 ashish 5750 
      oprot.writeFieldBegin('success', TType.I64, 0)
5751 
      oprot.writeI64(self.success)
5752 
      oprot.writeFieldEnd()
3431 rajveer 5753 
    if self.ex is not None:
94 ashish 5754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5755 
      self.ex.write(oprot)
5756 
      oprot.writeFieldEnd()
5757 
    oprot.writeFieldStop()
5758 
    oprot.writeStructEnd()
5759 
 
3431 rajveer 5760 
  def validate(self):
5761 
    return
5762 
 
5763 
 
94 ashish 5764 
  def __repr__(self):
5765 
    L = ['%s=%r' % (key, value)
5766 
      for key, value in self.__dict__.iteritems()]
5767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5768 
 
5769 
  def __eq__(self, other):
5770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5771 
 
5772 
  def __ne__(self, other):
5773 
    return not (self == other)
5774 
 
5775 
class getTransaction_args:
5776 
  """
5777 
  Attributes:
5778 
   - id
5779 
  """
5780 
 
5781 
  thrift_spec = (
5782 
    None, # 0
5783 
    (1, TType.I64, 'id', None, None, ), # 1
5784 
  )
5785 
 
5786 
  def __init__(self, id=None,):
5787 
    self.id = id
5788 
 
5789 
  def read(self, iprot):
5790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5792 
      return
5793 
    iprot.readStructBegin()
5794 
    while True:
5795 
      (fname, ftype, fid) = iprot.readFieldBegin()
5796 
      if ftype == TType.STOP:
5797 
        break
5798 
      if fid == 1:
5799 
        if ftype == TType.I64:
5800 
          self.id = iprot.readI64();
5801 
        else:
5802 
          iprot.skip(ftype)
5803 
      else:
5804 
        iprot.skip(ftype)
5805 
      iprot.readFieldEnd()
5806 
    iprot.readStructEnd()
5807 
 
5808 
  def write(self, oprot):
5809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5811 
      return
5812 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5813 
    if self.id is not None:
94 ashish 5814 
      oprot.writeFieldBegin('id', TType.I64, 1)
5815 
      oprot.writeI64(self.id)
5816 
      oprot.writeFieldEnd()
5817 
    oprot.writeFieldStop()
5818 
    oprot.writeStructEnd()
5819 
 
3431 rajveer 5820 
  def validate(self):
5821 
    return
5822 
 
5823 
 
94 ashish 5824 
  def __repr__(self):
5825 
    L = ['%s=%r' % (key, value)
5826 
      for key, value in self.__dict__.iteritems()]
5827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5828 
 
5829 
  def __eq__(self, other):
5830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5831 
 
5832 
  def __ne__(self, other):
5833 
    return not (self == other)
5834 
 
5835 
class getTransaction_result:
5836 
  """
5837 
  Attributes:
5838 
   - success
5839 
   - ex
5840 
  """
5841 
 
5842 
  thrift_spec = (
5843 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5845 
  )
5846 
 
5847 
  def __init__(self, success=None, ex=None,):
5848 
    self.success = success
5849 
    self.ex = ex
5850 
 
5851 
  def read(self, iprot):
5852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5854 
      return
5855 
    iprot.readStructBegin()
5856 
    while True:
5857 
      (fname, ftype, fid) = iprot.readFieldBegin()
5858 
      if ftype == TType.STOP:
5859 
        break
5860 
      if fid == 0:
5861 
        if ftype == TType.STRUCT:
5862 
          self.success = Transaction()
5863 
          self.success.read(iprot)
5864 
        else:
5865 
          iprot.skip(ftype)
5866 
      elif fid == 1:
5867 
        if ftype == TType.STRUCT:
5868 
          self.ex = TransactionServiceException()
5869 
          self.ex.read(iprot)
5870 
        else:
5871 
          iprot.skip(ftype)
5872 
      else:
5873 
        iprot.skip(ftype)
5874 
      iprot.readFieldEnd()
5875 
    iprot.readStructEnd()
5876 
 
5877 
  def write(self, oprot):
5878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5880 
      return
5881 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5882 
    if self.success is not None:
94 ashish 5883 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5884 
      self.success.write(oprot)
5885 
      oprot.writeFieldEnd()
3431 rajveer 5886 
    if self.ex is not None:
94 ashish 5887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5888 
      self.ex.write(oprot)
5889 
      oprot.writeFieldEnd()
5890 
    oprot.writeFieldStop()
5891 
    oprot.writeStructEnd()
5892 
 
3431 rajveer 5893 
  def validate(self):
5894 
    return
5895 
 
5896 
 
94 ashish 5897 
  def __repr__(self):
5898 
    L = ['%s=%r' % (key, value)
5899 
      for key, value in self.__dict__.iteritems()]
5900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5901 
 
5902 
  def __eq__(self, other):
5903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5904 
 
5905 
  def __ne__(self, other):
5906 
    return not (self == other)
5907 
 
5908 
class getTransactionsForCustomer_args:
5909 
  """
5910 
  Attributes:
5911 
   - customerId
5912 
   - from_date
5913 
   - to_date
5914 
   - status
5915 
  """
5916 
 
5917 
  thrift_spec = (
5918 
    None, # 0
5919 
    (1, TType.I64, 'customerId', None, None, ), # 1
5920 
    (2, TType.I64, 'from_date', None, None, ), # 2
5921 
    (3, TType.I64, 'to_date', None, None, ), # 3
5922 
    (4, TType.I32, 'status', None, None, ), # 4
5923 
  )
5924 
 
5925 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5926 
    self.customerId = customerId
5927 
    self.from_date = from_date
5928 
    self.to_date = to_date
5929 
    self.status = status
5930 
 
5931 
  def read(self, iprot):
5932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5934 
      return
5935 
    iprot.readStructBegin()
5936 
    while True:
5937 
      (fname, ftype, fid) = iprot.readFieldBegin()
5938 
      if ftype == TType.STOP:
5939 
        break
5940 
      if fid == 1:
5941 
        if ftype == TType.I64:
5942 
          self.customerId = iprot.readI64();
5943 
        else:
5944 
          iprot.skip(ftype)
5945 
      elif fid == 2:
5946 
        if ftype == TType.I64:
5947 
          self.from_date = iprot.readI64();
5948 
        else:
5949 
          iprot.skip(ftype)
5950 
      elif fid == 3:
5951 
        if ftype == TType.I64:
5952 
          self.to_date = iprot.readI64();
5953 
        else:
5954 
          iprot.skip(ftype)
5955 
      elif fid == 4:
5956 
        if ftype == TType.I32:
5957 
          self.status = iprot.readI32();
5958 
        else:
5959 
          iprot.skip(ftype)
5960 
      else:
5961 
        iprot.skip(ftype)
5962 
      iprot.readFieldEnd()
5963 
    iprot.readStructEnd()
5964 
 
5965 
  def write(self, oprot):
5966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5968 
      return
5969 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5970 
    if self.customerId is not None:
94 ashish 5971 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5972 
      oprot.writeI64(self.customerId)
5973 
      oprot.writeFieldEnd()
3431 rajveer 5974 
    if self.from_date is not None:
94 ashish 5975 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5976 
      oprot.writeI64(self.from_date)
5977 
      oprot.writeFieldEnd()
3431 rajveer 5978 
    if self.to_date is not None:
94 ashish 5979 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5980 
      oprot.writeI64(self.to_date)
5981 
      oprot.writeFieldEnd()
3431 rajveer 5982 
    if self.status is not None:
94 ashish 5983 
      oprot.writeFieldBegin('status', TType.I32, 4)
5984 
      oprot.writeI32(self.status)
5985 
      oprot.writeFieldEnd()
5986 
    oprot.writeFieldStop()
5987 
    oprot.writeStructEnd()
5988 
 
3431 rajveer 5989 
  def validate(self):
5990 
    return
5991 
 
5992 
 
94 ashish 5993 
  def __repr__(self):
5994 
    L = ['%s=%r' % (key, value)
5995 
      for key, value in self.__dict__.iteritems()]
5996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5997 
 
5998 
  def __eq__(self, other):
5999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6000 
 
6001 
  def __ne__(self, other):
6002 
    return not (self == other)
6003 
 
6004 
class getTransactionsForCustomer_result:
6005 
  """
6006 
  Attributes:
6007 
   - success
6008 
   - ex
6009 
  """
6010 
 
6011 
  thrift_spec = (
6012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6014 
  )
6015 
 
6016 
  def __init__(self, success=None, ex=None,):
6017 
    self.success = success
6018 
    self.ex = ex
6019 
 
6020 
  def read(self, iprot):
6021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6023 
      return
6024 
    iprot.readStructBegin()
6025 
    while True:
6026 
      (fname, ftype, fid) = iprot.readFieldBegin()
6027 
      if ftype == TType.STOP:
6028 
        break
6029 
      if fid == 0:
6030 
        if ftype == TType.LIST:
6031 
          self.success = []
685 chandransh 6032 
          (_etype17, _size14) = iprot.readListBegin()
6033 
          for _i18 in xrange(_size14):
6034 
            _elem19 = Transaction()
6035 
            _elem19.read(iprot)
6036 
            self.success.append(_elem19)
94 ashish 6037 
          iprot.readListEnd()
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      elif fid == 1:
6041 
        if ftype == TType.STRUCT:
6042 
          self.ex = TransactionServiceException()
6043 
          self.ex.read(iprot)
6044 
        else:
6045 
          iprot.skip(ftype)
6046 
      else:
6047 
        iprot.skip(ftype)
6048 
      iprot.readFieldEnd()
6049 
    iprot.readStructEnd()
6050 
 
6051 
  def write(self, oprot):
6052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6054 
      return
6055 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6056 
    if self.success is not None:
94 ashish 6057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6059 
      for iter20 in self.success:
6060 
        iter20.write(oprot)
94 ashish 6061 
      oprot.writeListEnd()
6062 
      oprot.writeFieldEnd()
3431 rajveer 6063 
    if self.ex is not None:
94 ashish 6064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6065 
      self.ex.write(oprot)
6066 
      oprot.writeFieldEnd()
6067 
    oprot.writeFieldStop()
6068 
    oprot.writeStructEnd()
6069 
 
3431 rajveer 6070 
  def validate(self):
6071 
    return
6072 
 
6073 
 
94 ashish 6074 
  def __repr__(self):
6075 
    L = ['%s=%r' % (key, value)
6076 
      for key, value in self.__dict__.iteritems()]
6077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6078 
 
6079 
  def __eq__(self, other):
6080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6081 
 
6082 
  def __ne__(self, other):
6083 
    return not (self == other)
6084 
 
132 ashish 6085 
class getTransactionsForShoppingCartId_args:
6086 
  """
6087 
  Attributes:
6088 
   - shoppingCartId
6089 
  """
6090 
 
6091 
  thrift_spec = (
6092 
    None, # 0
6093 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6094 
  )
6095 
 
6096 
  def __init__(self, shoppingCartId=None,):
6097 
    self.shoppingCartId = shoppingCartId
6098 
 
6099 
  def read(self, iprot):
6100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6102 
      return
6103 
    iprot.readStructBegin()
6104 
    while True:
6105 
      (fname, ftype, fid) = iprot.readFieldBegin()
6106 
      if ftype == TType.STOP:
6107 
        break
6108 
      if fid == 1:
6109 
        if ftype == TType.I64:
6110 
          self.shoppingCartId = iprot.readI64();
6111 
        else:
6112 
          iprot.skip(ftype)
6113 
      else:
6114 
        iprot.skip(ftype)
6115 
      iprot.readFieldEnd()
6116 
    iprot.readStructEnd()
6117 
 
6118 
  def write(self, oprot):
6119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6121 
      return
6122 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6123 
    if self.shoppingCartId is not None:
132 ashish 6124 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6125 
      oprot.writeI64(self.shoppingCartId)
6126 
      oprot.writeFieldEnd()
6127 
    oprot.writeFieldStop()
6128 
    oprot.writeStructEnd()
6129 
 
3431 rajveer 6130 
  def validate(self):
6131 
    return
6132 
 
6133 
 
132 ashish 6134 
  def __repr__(self):
6135 
    L = ['%s=%r' % (key, value)
6136 
      for key, value in self.__dict__.iteritems()]
6137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6138 
 
6139 
  def __eq__(self, other):
6140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6141 
 
6142 
  def __ne__(self, other):
6143 
    return not (self == other)
6144 
 
6145 
class getTransactionsForShoppingCartId_result:
6146 
  """
6147 
  Attributes:
6148 
   - success
6149 
   - ex
6150 
  """
6151 
 
6152 
  thrift_spec = (
6153 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6155 
  )
6156 
 
6157 
  def __init__(self, success=None, ex=None,):
6158 
    self.success = success
6159 
    self.ex = ex
6160 
 
6161 
  def read(self, iprot):
6162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6164 
      return
6165 
    iprot.readStructBegin()
6166 
    while True:
6167 
      (fname, ftype, fid) = iprot.readFieldBegin()
6168 
      if ftype == TType.STOP:
6169 
        break
6170 
      if fid == 0:
6171 
        if ftype == TType.LIST:
6172 
          self.success = []
685 chandransh 6173 
          (_etype24, _size21) = iprot.readListBegin()
6174 
          for _i25 in xrange(_size21):
6175 
            _elem26 = Transaction()
6176 
            _elem26.read(iprot)
6177 
            self.success.append(_elem26)
132 ashish 6178 
          iprot.readListEnd()
6179 
        else:
6180 
          iprot.skip(ftype)
6181 
      elif fid == 1:
6182 
        if ftype == TType.STRUCT:
6183 
          self.ex = TransactionServiceException()
6184 
          self.ex.read(iprot)
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      else:
6188 
        iprot.skip(ftype)
6189 
      iprot.readFieldEnd()
6190 
    iprot.readStructEnd()
6191 
 
6192 
  def write(self, oprot):
6193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6195 
      return
6196 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6197 
    if self.success is not None:
132 ashish 6198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6200 
      for iter27 in self.success:
6201 
        iter27.write(oprot)
132 ashish 6202 
      oprot.writeListEnd()
6203 
      oprot.writeFieldEnd()
3431 rajveer 6204 
    if self.ex is not None:
132 ashish 6205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6206 
      self.ex.write(oprot)
6207 
      oprot.writeFieldEnd()
6208 
    oprot.writeFieldStop()
6209 
    oprot.writeStructEnd()
6210 
 
3431 rajveer 6211 
  def validate(self):
6212 
    return
6213 
 
6214 
 
132 ashish 6215 
  def __repr__(self):
6216 
    L = ['%s=%r' % (key, value)
6217 
      for key, value in self.__dict__.iteritems()]
6218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6219 
 
6220 
  def __eq__(self, other):
6221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6222 
 
6223 
  def __ne__(self, other):
6224 
    return not (self == other)
6225 
 
94 ashish 6226 
class getTransactionStatus_args:
6227 
  """
6228 
  Attributes:
6229 
   - transactionId
6230 
  """
6231 
 
6232 
  thrift_spec = (
6233 
    None, # 0
6234 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6235 
  )
6236 
 
6237 
  def __init__(self, transactionId=None,):
6238 
    self.transactionId = transactionId
6239 
 
6240 
  def read(self, iprot):
6241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6243 
      return
6244 
    iprot.readStructBegin()
6245 
    while True:
6246 
      (fname, ftype, fid) = iprot.readFieldBegin()
6247 
      if ftype == TType.STOP:
6248 
        break
6249 
      if fid == 1:
6250 
        if ftype == TType.I64:
6251 
          self.transactionId = iprot.readI64();
6252 
        else:
6253 
          iprot.skip(ftype)
6254 
      else:
6255 
        iprot.skip(ftype)
6256 
      iprot.readFieldEnd()
6257 
    iprot.readStructEnd()
6258 
 
6259 
  def write(self, oprot):
6260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6262 
      return
6263 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6264 
    if self.transactionId is not None:
94 ashish 6265 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6266 
      oprot.writeI64(self.transactionId)
6267 
      oprot.writeFieldEnd()
6268 
    oprot.writeFieldStop()
6269 
    oprot.writeStructEnd()
6270 
 
3431 rajveer 6271 
  def validate(self):
6272 
    return
6273 
 
6274 
 
94 ashish 6275 
  def __repr__(self):
6276 
    L = ['%s=%r' % (key, value)
6277 
      for key, value in self.__dict__.iteritems()]
6278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6279 
 
6280 
  def __eq__(self, other):
6281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6282 
 
6283 
  def __ne__(self, other):
6284 
    return not (self == other)
6285 
 
6286 
class getTransactionStatus_result:
6287 
  """
6288 
  Attributes:
6289 
   - success
6290 
   - ex
6291 
  """
6292 
 
6293 
  thrift_spec = (
6294 
    (0, TType.I32, 'success', None, None, ), # 0
6295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6296 
  )
6297 
 
6298 
  def __init__(self, success=None, ex=None,):
6299 
    self.success = success
6300 
    self.ex = ex
6301 
 
6302 
  def read(self, iprot):
6303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6305 
      return
6306 
    iprot.readStructBegin()
6307 
    while True:
6308 
      (fname, ftype, fid) = iprot.readFieldBegin()
6309 
      if ftype == TType.STOP:
6310 
        break
6311 
      if fid == 0:
6312 
        if ftype == TType.I32:
6313 
          self.success = iprot.readI32();
6314 
        else:
6315 
          iprot.skip(ftype)
6316 
      elif fid == 1:
6317 
        if ftype == TType.STRUCT:
6318 
          self.ex = TransactionServiceException()
6319 
          self.ex.read(iprot)
6320 
        else:
6321 
          iprot.skip(ftype)
6322 
      else:
6323 
        iprot.skip(ftype)
6324 
      iprot.readFieldEnd()
6325 
    iprot.readStructEnd()
6326 
 
6327 
  def write(self, oprot):
6328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6330 
      return
6331 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6332 
    if self.success is not None:
94 ashish 6333 
      oprot.writeFieldBegin('success', TType.I32, 0)
6334 
      oprot.writeI32(self.success)
6335 
      oprot.writeFieldEnd()
3431 rajveer 6336 
    if self.ex is not None:
94 ashish 6337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6338 
      self.ex.write(oprot)
6339 
      oprot.writeFieldEnd()
6340 
    oprot.writeFieldStop()
6341 
    oprot.writeStructEnd()
6342 
 
3431 rajveer 6343 
  def validate(self):
6344 
    return
6345 
 
6346 
 
94 ashish 6347 
  def __repr__(self):
6348 
    L = ['%s=%r' % (key, value)
6349 
      for key, value in self.__dict__.iteritems()]
6350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6351 
 
6352 
  def __eq__(self, other):
6353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6354 
 
6355 
  def __ne__(self, other):
6356 
    return not (self == other)
6357 
 
6358 
class changeTransactionStatus_args:
6359 
  """
6360 
  Attributes:
6361 
   - transactionId
6362 
   - status
6363 
   - description
6364 
  """
6365 
 
6366 
  thrift_spec = (
6367 
    None, # 0
6368 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6369 
    (2, TType.I32, 'status', None, None, ), # 2
6370 
    (3, TType.STRING, 'description', None, None, ), # 3
6371 
  )
6372 
 
6373 
  def __init__(self, transactionId=None, status=None, description=None,):
6374 
    self.transactionId = transactionId
6375 
    self.status = status
6376 
    self.description = description
6377 
 
6378 
  def read(self, iprot):
6379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6381 
      return
6382 
    iprot.readStructBegin()
6383 
    while True:
6384 
      (fname, ftype, fid) = iprot.readFieldBegin()
6385 
      if ftype == TType.STOP:
6386 
        break
6387 
      if fid == 1:
6388 
        if ftype == TType.I64:
6389 
          self.transactionId = iprot.readI64();
6390 
        else:
6391 
          iprot.skip(ftype)
6392 
      elif fid == 2:
6393 
        if ftype == TType.I32:
6394 
          self.status = iprot.readI32();
6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      elif fid == 3:
6398 
        if ftype == TType.STRING:
6399 
          self.description = iprot.readString();
6400 
        else:
6401 
          iprot.skip(ftype)
6402 
      else:
6403 
        iprot.skip(ftype)
6404 
      iprot.readFieldEnd()
6405 
    iprot.readStructEnd()
6406 
 
6407 
  def write(self, oprot):
6408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6410 
      return
6411 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6412 
    if self.transactionId is not None:
94 ashish 6413 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6414 
      oprot.writeI64(self.transactionId)
6415 
      oprot.writeFieldEnd()
3431 rajveer 6416 
    if self.status is not None:
94 ashish 6417 
      oprot.writeFieldBegin('status', TType.I32, 2)
6418 
      oprot.writeI32(self.status)
6419 
      oprot.writeFieldEnd()
3431 rajveer 6420 
    if self.description is not None:
94 ashish 6421 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6422 
      oprot.writeString(self.description)
6423 
      oprot.writeFieldEnd()
6424 
    oprot.writeFieldStop()
6425 
    oprot.writeStructEnd()
6426 
 
3431 rajveer 6427 
  def validate(self):
6428 
    return
6429 
 
6430 
 
94 ashish 6431 
  def __repr__(self):
6432 
    L = ['%s=%r' % (key, value)
6433 
      for key, value in self.__dict__.iteritems()]
6434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6435 
 
6436 
  def __eq__(self, other):
6437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6438 
 
6439 
  def __ne__(self, other):
6440 
    return not (self == other)
6441 
 
6442 
class changeTransactionStatus_result:
6443 
  """
6444 
  Attributes:
6445 
   - success
6446 
   - ex
6447 
  """
6448 
 
6449 
  thrift_spec = (
6450 
    (0, TType.BOOL, 'success', None, None, ), # 0
6451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6452 
  )
6453 
 
6454 
  def __init__(self, success=None, ex=None,):
6455 
    self.success = success
6456 
    self.ex = ex
6457 
 
6458 
  def read(self, iprot):
6459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6461 
      return
6462 
    iprot.readStructBegin()
6463 
    while True:
6464 
      (fname, ftype, fid) = iprot.readFieldBegin()
6465 
      if ftype == TType.STOP:
6466 
        break
6467 
      if fid == 0:
6468 
        if ftype == TType.BOOL:
6469 
          self.success = iprot.readBool();
6470 
        else:
6471 
          iprot.skip(ftype)
6472 
      elif fid == 1:
6473 
        if ftype == TType.STRUCT:
6474 
          self.ex = TransactionServiceException()
6475 
          self.ex.read(iprot)
6476 
        else:
6477 
          iprot.skip(ftype)
6478 
      else:
6479 
        iprot.skip(ftype)
6480 
      iprot.readFieldEnd()
6481 
    iprot.readStructEnd()
6482 
 
6483 
  def write(self, oprot):
6484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6486 
      return
6487 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6488 
    if self.success is not None:
94 ashish 6489 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6490 
      oprot.writeBool(self.success)
6491 
      oprot.writeFieldEnd()
3431 rajveer 6492 
    if self.ex is not None:
94 ashish 6493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6494 
      self.ex.write(oprot)
6495 
      oprot.writeFieldEnd()
6496 
    oprot.writeFieldStop()
6497 
    oprot.writeStructEnd()
6498 
 
3431 rajveer 6499 
  def validate(self):
6500 
    return
6501 
 
6502 
 
94 ashish 6503 
  def __repr__(self):
6504 
    L = ['%s=%r' % (key, value)
6505 
      for key, value in self.__dict__.iteritems()]
6506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6507 
 
6508 
  def __eq__(self, other):
6509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6510 
 
6511 
  def __ne__(self, other):
6512 
    return not (self == other)
6513 
 
1398 varun.gupt 6514 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6515 
  """
6516 
  Attributes:
6517 
   - transactionId
6518 
  """
6519 
 
6520 
  thrift_spec = (
6521 
    None, # 0
6522 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6523 
  )
6524 
 
6525 
  def __init__(self, transactionId=None,):
6526 
    self.transactionId = transactionId
6527 
 
6528 
  def read(self, iprot):
6529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6531 
      return
6532 
    iprot.readStructBegin()
6533 
    while True:
6534 
      (fname, ftype, fid) = iprot.readFieldBegin()
6535 
      if ftype == TType.STOP:
6536 
        break
6537 
      if fid == 1:
6538 
        if ftype == TType.I64:
6539 
          self.transactionId = iprot.readI64();
6540 
        else:
6541 
          iprot.skip(ftype)
6542 
      else:
6543 
        iprot.skip(ftype)
6544 
      iprot.readFieldEnd()
6545 
    iprot.readStructEnd()
6546 
 
6547 
  def write(self, oprot):
6548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6550 
      return
1398 varun.gupt 6551 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6552 
    if self.transactionId is not None:
1382 varun.gupt 6553 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6554 
      oprot.writeI64(self.transactionId)
6555 
      oprot.writeFieldEnd()
6556 
    oprot.writeFieldStop()
6557 
    oprot.writeStructEnd()
6558 
 
3431 rajveer 6559 
  def validate(self):
6560 
    return
6561 
 
6562 
 
1382 varun.gupt 6563 
  def __repr__(self):
6564 
    L = ['%s=%r' % (key, value)
6565 
      for key, value in self.__dict__.iteritems()]
6566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6567 
 
6568 
  def __eq__(self, other):
6569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6570 
 
6571 
  def __ne__(self, other):
6572 
    return not (self == other)
6573 
 
1398 varun.gupt 6574 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6575 
  """
6576 
  Attributes:
6577 
   - success
6578 
   - ex
6579 
  """
6580 
 
6581 
  thrift_spec = (
6582 
    (0, TType.BOOL, 'success', None, None, ), # 0
6583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6584 
  )
6585 
 
6586 
  def __init__(self, success=None, ex=None,):
6587 
    self.success = success
6588 
    self.ex = ex
6589 
 
6590 
  def read(self, iprot):
6591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6593 
      return
6594 
    iprot.readStructBegin()
6595 
    while True:
6596 
      (fname, ftype, fid) = iprot.readFieldBegin()
6597 
      if ftype == TType.STOP:
6598 
        break
6599 
      if fid == 0:
6600 
        if ftype == TType.BOOL:
6601 
          self.success = iprot.readBool();
6602 
        else:
6603 
          iprot.skip(ftype)
6604 
      elif fid == 1:
6605 
        if ftype == TType.STRUCT:
6606 
          self.ex = TransactionServiceException()
6607 
          self.ex.read(iprot)
6608 
        else:
6609 
          iprot.skip(ftype)
6610 
      else:
6611 
        iprot.skip(ftype)
6612 
      iprot.readFieldEnd()
6613 
    iprot.readStructEnd()
6614 
 
6615 
  def write(self, oprot):
6616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6618 
      return
1398 varun.gupt 6619 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6620 
    if self.success is not None:
1382 varun.gupt 6621 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6622 
      oprot.writeBool(self.success)
6623 
      oprot.writeFieldEnd()
3431 rajveer 6624 
    if self.ex is not None:
1382 varun.gupt 6625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6626 
      self.ex.write(oprot)
6627 
      oprot.writeFieldEnd()
6628 
    oprot.writeFieldStop()
6629 
    oprot.writeStructEnd()
6630 
 
3431 rajveer 6631 
  def validate(self):
6632 
    return
6633 
 
6634 
 
1382 varun.gupt 6635 
  def __repr__(self):
6636 
    L = ['%s=%r' % (key, value)
6637 
      for key, value in self.__dict__.iteritems()]
6638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6639 
 
6640 
  def __eq__(self, other):
6641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6642 
 
6643 
  def __ne__(self, other):
6644 
    return not (self == other)
6645 
 
483 rajveer 6646 
class getAllOrders_args:
94 ashish 6647 
  """
6648 
  Attributes:
483 rajveer 6649 
   - status
6650 
   - from_date
6651 
   - to_date
6652 
   - warehouse_id
94 ashish 6653 
  """
6654 
 
6655 
  thrift_spec = (
6656 
    None, # 0
483 rajveer 6657 
    (1, TType.I32, 'status', None, None, ), # 1
6658 
    (2, TType.I64, 'from_date', None, None, ), # 2
6659 
    (3, TType.I64, 'to_date', None, None, ), # 3
6660 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6661 
  )
6662 
 
483 rajveer 6663 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6664 
    self.status = status
6665 
    self.from_date = from_date
6666 
    self.to_date = to_date
6667 
    self.warehouse_id = warehouse_id
94 ashish 6668 
 
6669 
  def read(self, iprot):
6670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6672 
      return
6673 
    iprot.readStructBegin()
6674 
    while True:
6675 
      (fname, ftype, fid) = iprot.readFieldBegin()
6676 
      if ftype == TType.STOP:
6677 
        break
6678 
      if fid == 1:
483 rajveer 6679 
        if ftype == TType.I32:
6680 
          self.status = iprot.readI32();
94 ashish 6681 
        else:
6682 
          iprot.skip(ftype)
483 rajveer 6683 
      elif fid == 2:
6684 
        if ftype == TType.I64:
6685 
          self.from_date = iprot.readI64();
94 ashish 6686 
        else:
6687 
          iprot.skip(ftype)
483 rajveer 6688 
      elif fid == 3:
6689 
        if ftype == TType.I64:
6690 
          self.to_date = iprot.readI64();
94 ashish 6691 
        else:
6692 
          iprot.skip(ftype)
483 rajveer 6693 
      elif fid == 4:
94 ashish 6694 
        if ftype == TType.I64:
483 rajveer 6695 
          self.warehouse_id = iprot.readI64();
94 ashish 6696 
        else:
6697 
          iprot.skip(ftype)
6698 
      else:
6699 
        iprot.skip(ftype)
6700 
      iprot.readFieldEnd()
6701 
    iprot.readStructEnd()
6702 
 
6703 
  def write(self, oprot):
6704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6706 
      return
483 rajveer 6707 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6708 
    if self.status is not None:
483 rajveer 6709 
      oprot.writeFieldBegin('status', TType.I32, 1)
6710 
      oprot.writeI32(self.status)
94 ashish 6711 
      oprot.writeFieldEnd()
3431 rajveer 6712 
    if self.from_date is not None:
483 rajveer 6713 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6714 
      oprot.writeI64(self.from_date)
94 ashish 6715 
      oprot.writeFieldEnd()
3431 rajveer 6716 
    if self.to_date is not None:
483 rajveer 6717 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6718 
      oprot.writeI64(self.to_date)
94 ashish 6719 
      oprot.writeFieldEnd()
3431 rajveer 6720 
    if self.warehouse_id is not None:
483 rajveer 6721 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6722 
      oprot.writeI64(self.warehouse_id)
94 ashish 6723 
      oprot.writeFieldEnd()
6724 
    oprot.writeFieldStop()
6725 
    oprot.writeStructEnd()
6726 
 
3431 rajveer 6727 
  def validate(self):
6728 
    return
6729 
 
6730 
 
94 ashish 6731 
  def __repr__(self):
6732 
    L = ['%s=%r' % (key, value)
6733 
      for key, value in self.__dict__.iteritems()]
6734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6735 
 
6736 
  def __eq__(self, other):
6737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6738 
 
6739 
  def __ne__(self, other):
6740 
    return not (self == other)
6741 
 
483 rajveer 6742 
class getAllOrders_result:
94 ashish 6743 
  """
6744 
  Attributes:
6745 
   - success
6746 
   - ex
6747 
  """
6748 
 
6749 
  thrift_spec = (
483 rajveer 6750 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6752 
  )
6753 
 
6754 
  def __init__(self, success=None, ex=None,):
6755 
    self.success = success
6756 
    self.ex = ex
6757 
 
6758 
  def read(self, iprot):
6759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6761 
      return
6762 
    iprot.readStructBegin()
6763 
    while True:
6764 
      (fname, ftype, fid) = iprot.readFieldBegin()
6765 
      if ftype == TType.STOP:
6766 
        break
6767 
      if fid == 0:
483 rajveer 6768 
        if ftype == TType.LIST:
6769 
          self.success = []
685 chandransh 6770 
          (_etype31, _size28) = iprot.readListBegin()
6771 
          for _i32 in xrange(_size28):
6772 
            _elem33 = Order()
6773 
            _elem33.read(iprot)
6774 
            self.success.append(_elem33)
483 rajveer 6775 
          iprot.readListEnd()
94 ashish 6776 
        else:
6777 
          iprot.skip(ftype)
6778 
      elif fid == 1:
6779 
        if ftype == TType.STRUCT:
6780 
          self.ex = TransactionServiceException()
6781 
          self.ex.read(iprot)
6782 
        else:
6783 
          iprot.skip(ftype)
6784 
      else:
6785 
        iprot.skip(ftype)
6786 
      iprot.readFieldEnd()
6787 
    iprot.readStructEnd()
6788 
 
6789 
  def write(self, oprot):
6790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6792 
      return
483 rajveer 6793 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6794 
    if self.success is not None:
483 rajveer 6795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6797 
      for iter34 in self.success:
6798 
        iter34.write(oprot)
483 rajveer 6799 
      oprot.writeListEnd()
94 ashish 6800 
      oprot.writeFieldEnd()
3431 rajveer 6801 
    if self.ex is not None:
94 ashish 6802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6803 
      self.ex.write(oprot)
6804 
      oprot.writeFieldEnd()
6805 
    oprot.writeFieldStop()
6806 
    oprot.writeStructEnd()
6807 
 
3431 rajveer 6808 
  def validate(self):
6809 
    return
6810 
 
6811 
 
94 ashish 6812 
  def __repr__(self):
6813 
    L = ['%s=%r' % (key, value)
6814 
      for key, value in self.__dict__.iteritems()]
6815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6816 
 
6817 
  def __eq__(self, other):
6818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6819 
 
6820 
  def __ne__(self, other):
6821 
    return not (self == other)
6822 
 
4133 chandransh 6823 
class getOrdersInBatch_args:
6824 
  """
6825 
  Attributes:
6826 
   - statuses
6827 
   - offset
6828 
   - limit
6829 
   - warehouse_id
6830 
  """
6831 
 
6832 
  thrift_spec = (
6833 
    None, # 0
6834 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6835 
    (2, TType.I64, 'offset', None, None, ), # 2
6836 
    (3, TType.I64, 'limit', None, None, ), # 3
6837 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6838 
  )
6839 
 
6840 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6841 
    self.statuses = statuses
6842 
    self.offset = offset
6843 
    self.limit = limit
6844 
    self.warehouse_id = warehouse_id
6845 
 
6846 
  def read(self, iprot):
6847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6849 
      return
6850 
    iprot.readStructBegin()
6851 
    while True:
6852 
      (fname, ftype, fid) = iprot.readFieldBegin()
6853 
      if ftype == TType.STOP:
6854 
        break
6855 
      if fid == 1:
6856 
        if ftype == TType.LIST:
6857 
          self.statuses = []
6858 
          (_etype38, _size35) = iprot.readListBegin()
6859 
          for _i39 in xrange(_size35):
6860 
            _elem40 = iprot.readI32();
6861 
            self.statuses.append(_elem40)
6862 
          iprot.readListEnd()
6863 
        else:
6864 
          iprot.skip(ftype)
6865 
      elif fid == 2:
6866 
        if ftype == TType.I64:
6867 
          self.offset = iprot.readI64();
6868 
        else:
6869 
          iprot.skip(ftype)
6870 
      elif fid == 3:
6871 
        if ftype == TType.I64:
6872 
          self.limit = iprot.readI64();
6873 
        else:
6874 
          iprot.skip(ftype)
6875 
      elif fid == 4:
6876 
        if ftype == TType.I64:
6877 
          self.warehouse_id = iprot.readI64();
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      else:
6881 
        iprot.skip(ftype)
6882 
      iprot.readFieldEnd()
6883 
    iprot.readStructEnd()
6884 
 
6885 
  def write(self, oprot):
6886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6888 
      return
6889 
    oprot.writeStructBegin('getOrdersInBatch_args')
6890 
    if self.statuses is not None:
6891 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6892 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6893 
      for iter41 in self.statuses:
6894 
        oprot.writeI32(iter41)
6895 
      oprot.writeListEnd()
6896 
      oprot.writeFieldEnd()
6897 
    if self.offset is not None:
6898 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6899 
      oprot.writeI64(self.offset)
6900 
      oprot.writeFieldEnd()
6901 
    if self.limit is not None:
6902 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6903 
      oprot.writeI64(self.limit)
6904 
      oprot.writeFieldEnd()
6905 
    if self.warehouse_id is not None:
6906 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6907 
      oprot.writeI64(self.warehouse_id)
6908 
      oprot.writeFieldEnd()
6909 
    oprot.writeFieldStop()
6910 
    oprot.writeStructEnd()
6911 
 
6912 
  def validate(self):
6913 
    return
6914 
 
6915 
 
6916 
  def __repr__(self):
6917 
    L = ['%s=%r' % (key, value)
6918 
      for key, value in self.__dict__.iteritems()]
6919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6920 
 
6921 
  def __eq__(self, other):
6922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6923 
 
6924 
  def __ne__(self, other):
6925 
    return not (self == other)
6926 
 
6927 
class getOrdersInBatch_result:
6928 
  """
6929 
  Attributes:
6930 
   - success
6931 
   - ex
6932 
  """
6933 
 
6934 
  thrift_spec = (
6935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6937 
  )
6938 
 
6939 
  def __init__(self, success=None, ex=None,):
6940 
    self.success = success
6941 
    self.ex = ex
6942 
 
6943 
  def read(self, iprot):
6944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6946 
      return
6947 
    iprot.readStructBegin()
6948 
    while True:
6949 
      (fname, ftype, fid) = iprot.readFieldBegin()
6950 
      if ftype == TType.STOP:
6951 
        break
6952 
      if fid == 0:
6953 
        if ftype == TType.LIST:
6954 
          self.success = []
6955 
          (_etype45, _size42) = iprot.readListBegin()
6956 
          for _i46 in xrange(_size42):
6957 
            _elem47 = Order()
6958 
            _elem47.read(iprot)
6959 
            self.success.append(_elem47)
6960 
          iprot.readListEnd()
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      elif fid == 1:
6964 
        if ftype == TType.STRUCT:
6965 
          self.ex = TransactionServiceException()
6966 
          self.ex.read(iprot)
6967 
        else:
6968 
          iprot.skip(ftype)
6969 
      else:
6970 
        iprot.skip(ftype)
6971 
      iprot.readFieldEnd()
6972 
    iprot.readStructEnd()
6973 
 
6974 
  def write(self, oprot):
6975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6977 
      return
6978 
    oprot.writeStructBegin('getOrdersInBatch_result')
6979 
    if self.success is not None:
6980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6982 
      for iter48 in self.success:
6983 
        iter48.write(oprot)
6984 
      oprot.writeListEnd()
6985 
      oprot.writeFieldEnd()
6986 
    if self.ex is not None:
6987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6988 
      self.ex.write(oprot)
6989 
      oprot.writeFieldEnd()
6990 
    oprot.writeFieldStop()
6991 
    oprot.writeStructEnd()
6992 
 
6993 
  def validate(self):
6994 
    return
6995 
 
6996 
 
6997 
  def __repr__(self):
6998 
    L = ['%s=%r' % (key, value)
6999 
      for key, value in self.__dict__.iteritems()]
7000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7001 
 
7002 
  def __eq__(self, other):
7003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7004 
 
7005 
  def __ne__(self, other):
7006 
    return not (self == other)
7007 
 
7008 
class getOrderCount_args:
7009 
  """
7010 
  Attributes:
7011 
   - statuses
7012 
   - warehouseId
7013 
  """
7014 
 
7015 
  thrift_spec = (
7016 
    None, # 0
7017 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7018 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7019 
  )
7020 
 
7021 
  def __init__(self, statuses=None, warehouseId=None,):
7022 
    self.statuses = statuses
7023 
    self.warehouseId = warehouseId
7024 
 
7025 
  def read(self, iprot):
7026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7028 
      return
7029 
    iprot.readStructBegin()
7030 
    while True:
7031 
      (fname, ftype, fid) = iprot.readFieldBegin()
7032 
      if ftype == TType.STOP:
7033 
        break
7034 
      if fid == 1:
7035 
        if ftype == TType.LIST:
7036 
          self.statuses = []
7037 
          (_etype52, _size49) = iprot.readListBegin()
7038 
          for _i53 in xrange(_size49):
7039 
            _elem54 = iprot.readI32();
7040 
            self.statuses.append(_elem54)
7041 
          iprot.readListEnd()
7042 
        else:
7043 
          iprot.skip(ftype)
7044 
      elif fid == 2:
7045 
        if ftype == TType.I64:
7046 
          self.warehouseId = iprot.readI64();
7047 
        else:
7048 
          iprot.skip(ftype)
7049 
      else:
7050 
        iprot.skip(ftype)
7051 
      iprot.readFieldEnd()
7052 
    iprot.readStructEnd()
7053 
 
7054 
  def write(self, oprot):
7055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7057 
      return
7058 
    oprot.writeStructBegin('getOrderCount_args')
7059 
    if self.statuses is not None:
7060 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7061 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7062 
      for iter55 in self.statuses:
7063 
        oprot.writeI32(iter55)
7064 
      oprot.writeListEnd()
7065 
      oprot.writeFieldEnd()
7066 
    if self.warehouseId is not None:
7067 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7068 
      oprot.writeI64(self.warehouseId)
7069 
      oprot.writeFieldEnd()
7070 
    oprot.writeFieldStop()
7071 
    oprot.writeStructEnd()
7072 
 
7073 
  def validate(self):
7074 
    return
7075 
 
7076 
 
7077 
  def __repr__(self):
7078 
    L = ['%s=%r' % (key, value)
7079 
      for key, value in self.__dict__.iteritems()]
7080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7081 
 
7082 
  def __eq__(self, other):
7083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7084 
 
7085 
  def __ne__(self, other):
7086 
    return not (self == other)
7087 
 
7088 
class getOrderCount_result:
7089 
  """
7090 
  Attributes:
7091 
   - success
7092 
   - ex
7093 
  """
7094 
 
7095 
  thrift_spec = (
7096 
    (0, TType.I32, 'success', None, None, ), # 0
7097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7098 
  )
7099 
 
7100 
  def __init__(self, success=None, ex=None,):
7101 
    self.success = success
7102 
    self.ex = ex
7103 
 
7104 
  def read(self, iprot):
7105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7107 
      return
7108 
    iprot.readStructBegin()
7109 
    while True:
7110 
      (fname, ftype, fid) = iprot.readFieldBegin()
7111 
      if ftype == TType.STOP:
7112 
        break
7113 
      if fid == 0:
7114 
        if ftype == TType.I32:
7115 
          self.success = iprot.readI32();
7116 
        else:
7117 
          iprot.skip(ftype)
7118 
      elif fid == 1:
7119 
        if ftype == TType.STRUCT:
7120 
          self.ex = TransactionServiceException()
7121 
          self.ex.read(iprot)
7122 
        else:
7123 
          iprot.skip(ftype)
7124 
      else:
7125 
        iprot.skip(ftype)
7126 
      iprot.readFieldEnd()
7127 
    iprot.readStructEnd()
7128 
 
7129 
  def write(self, oprot):
7130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7132 
      return
7133 
    oprot.writeStructBegin('getOrderCount_result')
7134 
    if self.success is not None:
7135 
      oprot.writeFieldBegin('success', TType.I32, 0)
7136 
      oprot.writeI32(self.success)
7137 
      oprot.writeFieldEnd()
7138 
    if self.ex is not None:
7139 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7140 
      self.ex.write(oprot)
7141 
      oprot.writeFieldEnd()
7142 
    oprot.writeFieldStop()
7143 
    oprot.writeStructEnd()
7144 
 
7145 
  def validate(self):
7146 
    return
7147 
 
7148 
 
7149 
  def __repr__(self):
7150 
    L = ['%s=%r' % (key, value)
7151 
      for key, value in self.__dict__.iteritems()]
7152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7153 
 
7154 
  def __eq__(self, other):
7155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7156 
 
7157 
  def __ne__(self, other):
7158 
    return not (self == other)
7159 
 
999 varun.gupt 7160 
class getOrdersByBillingDate_args:
7161 
  """
7162 
  Attributes:
7163 
   - status
7164 
   - start_billing_date
7165 
   - end_billing_date
7166 
   - warehouse_id
7167 
  """
7168 
 
7169 
  thrift_spec = (
7170 
    None, # 0
7171 
    (1, TType.I32, 'status', None, None, ), # 1
7172 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7173 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7174 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7175 
  )
7176 
 
7177 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7178 
    self.status = status
7179 
    self.start_billing_date = start_billing_date
7180 
    self.end_billing_date = end_billing_date
7181 
    self.warehouse_id = warehouse_id
7182 
 
7183 
  def read(self, iprot):
7184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7186 
      return
7187 
    iprot.readStructBegin()
7188 
    while True:
7189 
      (fname, ftype, fid) = iprot.readFieldBegin()
7190 
      if ftype == TType.STOP:
7191 
        break
7192 
      if fid == 1:
7193 
        if ftype == TType.I32:
7194 
          self.status = iprot.readI32();
7195 
        else:
7196 
          iprot.skip(ftype)
7197 
      elif fid == 2:
7198 
        if ftype == TType.I64:
7199 
          self.start_billing_date = iprot.readI64();
7200 
        else:
7201 
          iprot.skip(ftype)
7202 
      elif fid == 3:
7203 
        if ftype == TType.I64:
7204 
          self.end_billing_date = iprot.readI64();
7205 
        else:
7206 
          iprot.skip(ftype)
7207 
      elif fid == 4:
7208 
        if ftype == TType.I64:
7209 
          self.warehouse_id = iprot.readI64();
7210 
        else:
7211 
          iprot.skip(ftype)
7212 
      else:
7213 
        iprot.skip(ftype)
7214 
      iprot.readFieldEnd()
7215 
    iprot.readStructEnd()
7216 
 
7217 
  def write(self, oprot):
7218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7220 
      return
7221 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7222 
    if self.status is not None:
999 varun.gupt 7223 
      oprot.writeFieldBegin('status', TType.I32, 1)
7224 
      oprot.writeI32(self.status)
7225 
      oprot.writeFieldEnd()
3431 rajveer 7226 
    if self.start_billing_date is not None:
999 varun.gupt 7227 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7228 
      oprot.writeI64(self.start_billing_date)
7229 
      oprot.writeFieldEnd()
3431 rajveer 7230 
    if self.end_billing_date is not None:
999 varun.gupt 7231 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7232 
      oprot.writeI64(self.end_billing_date)
7233 
      oprot.writeFieldEnd()
3431 rajveer 7234 
    if self.warehouse_id is not None:
999 varun.gupt 7235 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7236 
      oprot.writeI64(self.warehouse_id)
7237 
      oprot.writeFieldEnd()
7238 
    oprot.writeFieldStop()
7239 
    oprot.writeStructEnd()
7240 
 
3431 rajveer 7241 
  def validate(self):
7242 
    return
7243 
 
7244 
 
999 varun.gupt 7245 
  def __repr__(self):
7246 
    L = ['%s=%r' % (key, value)
7247 
      for key, value in self.__dict__.iteritems()]
7248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7249 
 
7250 
  def __eq__(self, other):
7251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7252 
 
7253 
  def __ne__(self, other):
7254 
    return not (self == other)
7255 
 
7256 
class getOrdersByBillingDate_result:
7257 
  """
7258 
  Attributes:
7259 
   - success
7260 
   - ex
7261 
  """
7262 
 
7263 
  thrift_spec = (
7264 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7266 
  )
7267 
 
7268 
  def __init__(self, success=None, ex=None,):
7269 
    self.success = success
7270 
    self.ex = ex
7271 
 
7272 
  def read(self, iprot):
7273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7275 
      return
7276 
    iprot.readStructBegin()
7277 
    while True:
7278 
      (fname, ftype, fid) = iprot.readFieldBegin()
7279 
      if ftype == TType.STOP:
7280 
        break
7281 
      if fid == 0:
7282 
        if ftype == TType.LIST:
7283 
          self.success = []
4133 chandransh 7284 
          (_etype59, _size56) = iprot.readListBegin()
7285 
          for _i60 in xrange(_size56):
7286 
            _elem61 = Order()
7287 
            _elem61.read(iprot)
7288 
            self.success.append(_elem61)
999 varun.gupt 7289 
          iprot.readListEnd()
7290 
        else:
7291 
          iprot.skip(ftype)
7292 
      elif fid == 1:
7293 
        if ftype == TType.STRUCT:
7294 
          self.ex = TransactionServiceException()
7295 
          self.ex.read(iprot)
7296 
        else:
7297 
          iprot.skip(ftype)
7298 
      else:
7299 
        iprot.skip(ftype)
7300 
      iprot.readFieldEnd()
7301 
    iprot.readStructEnd()
7302 
 
7303 
  def write(self, oprot):
7304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7306 
      return
7307 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7308 
    if self.success is not None:
999 varun.gupt 7309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7311 
      for iter62 in self.success:
7312 
        iter62.write(oprot)
999 varun.gupt 7313 
      oprot.writeListEnd()
7314 
      oprot.writeFieldEnd()
3431 rajveer 7315 
    if self.ex is not None:
999 varun.gupt 7316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7317 
      self.ex.write(oprot)
7318 
      oprot.writeFieldEnd()
7319 
    oprot.writeFieldStop()
7320 
    oprot.writeStructEnd()
7321 
 
3431 rajveer 7322 
  def validate(self):
7323 
    return
7324 
 
7325 
 
999 varun.gupt 7326 
  def __repr__(self):
7327 
    L = ['%s=%r' % (key, value)
7328 
      for key, value in self.__dict__.iteritems()]
7329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7330 
 
7331 
  def __eq__(self, other):
7332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7333 
 
7334 
  def __ne__(self, other):
7335 
    return not (self == other)
7336 
 
3427 chandransh 7337 
class getOrdersByShippingDate_args:
7338 
  """
7339 
  Attributes:
7340 
   - fromShippingDate
7341 
   - toShippingDate
7342 
   - providerId
7343 
   - warehouseId
3451 chandransh 7344 
   - cod
3427 chandransh 7345 
  """
7346 
 
7347 
  thrift_spec = (
7348 
    None, # 0
7349 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7350 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7351 
    (3, TType.I64, 'providerId', None, None, ), # 3
7352 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7353 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7354 
  )
7355 
 
3451 chandransh 7356 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7357 
    self.fromShippingDate = fromShippingDate
7358 
    self.toShippingDate = toShippingDate
7359 
    self.providerId = providerId
7360 
    self.warehouseId = warehouseId
3451 chandransh 7361 
    self.cod = cod
3427 chandransh 7362 
 
7363 
  def read(self, iprot):
7364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7366 
      return
7367 
    iprot.readStructBegin()
7368 
    while True:
7369 
      (fname, ftype, fid) = iprot.readFieldBegin()
7370 
      if ftype == TType.STOP:
7371 
        break
7372 
      if fid == 1:
7373 
        if ftype == TType.I64:
7374 
          self.fromShippingDate = iprot.readI64();
7375 
        else:
7376 
          iprot.skip(ftype)
7377 
      elif fid == 2:
7378 
        if ftype == TType.I64:
7379 
          self.toShippingDate = iprot.readI64();
7380 
        else:
7381 
          iprot.skip(ftype)
7382 
      elif fid == 3:
7383 
        if ftype == TType.I64:
7384 
          self.providerId = iprot.readI64();
7385 
        else:
7386 
          iprot.skip(ftype)
7387 
      elif fid == 4:
7388 
        if ftype == TType.I64:
7389 
          self.warehouseId = iprot.readI64();
7390 
        else:
7391 
          iprot.skip(ftype)
3451 chandransh 7392 
      elif fid == 5:
7393 
        if ftype == TType.BOOL:
7394 
          self.cod = iprot.readBool();
7395 
        else:
7396 
          iprot.skip(ftype)
3427 chandransh 7397 
      else:
7398 
        iprot.skip(ftype)
7399 
      iprot.readFieldEnd()
7400 
    iprot.readStructEnd()
7401 
 
7402 
  def write(self, oprot):
7403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7405 
      return
7406 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7407 
    if self.fromShippingDate is not None:
3427 chandransh 7408 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7409 
      oprot.writeI64(self.fromShippingDate)
7410 
      oprot.writeFieldEnd()
3431 rajveer 7411 
    if self.toShippingDate is not None:
3427 chandransh 7412 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7413 
      oprot.writeI64(self.toShippingDate)
7414 
      oprot.writeFieldEnd()
3431 rajveer 7415 
    if self.providerId is not None:
3427 chandransh 7416 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7417 
      oprot.writeI64(self.providerId)
7418 
      oprot.writeFieldEnd()
3431 rajveer 7419 
    if self.warehouseId is not None:
3427 chandransh 7420 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7421 
      oprot.writeI64(self.warehouseId)
7422 
      oprot.writeFieldEnd()
3451 chandransh 7423 
    if self.cod is not None:
7424 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7425 
      oprot.writeBool(self.cod)
7426 
      oprot.writeFieldEnd()
3427 chandransh 7427 
    oprot.writeFieldStop()
7428 
    oprot.writeStructEnd()
7429 
 
3431 rajveer 7430 
  def validate(self):
7431 
    return
7432 
 
7433 
 
3427 chandransh 7434 
  def __repr__(self):
7435 
    L = ['%s=%r' % (key, value)
7436 
      for key, value in self.__dict__.iteritems()]
7437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7438 
 
7439 
  def __eq__(self, other):
7440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7441 
 
7442 
  def __ne__(self, other):
7443 
    return not (self == other)
7444 
 
7445 
class getOrdersByShippingDate_result:
7446 
  """
7447 
  Attributes:
7448 
   - success
7449 
   - ex
7450 
  """
7451 
 
7452 
  thrift_spec = (
7453 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7454 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7455 
  )
7456 
 
7457 
  def __init__(self, success=None, ex=None,):
7458 
    self.success = success
7459 
    self.ex = ex
7460 
 
7461 
  def read(self, iprot):
7462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7464 
      return
7465 
    iprot.readStructBegin()
7466 
    while True:
7467 
      (fname, ftype, fid) = iprot.readFieldBegin()
7468 
      if ftype == TType.STOP:
7469 
        break
7470 
      if fid == 0:
7471 
        if ftype == TType.LIST:
7472 
          self.success = []
4133 chandransh 7473 
          (_etype66, _size63) = iprot.readListBegin()
7474 
          for _i67 in xrange(_size63):
7475 
            _elem68 = Order()
7476 
            _elem68.read(iprot)
7477 
            self.success.append(_elem68)
3427 chandransh 7478 
          iprot.readListEnd()
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 1:
7482 
        if ftype == TType.STRUCT:
7483 
          self.ex = TransactionServiceException()
7484 
          self.ex.read(iprot)
7485 
        else:
7486 
          iprot.skip(ftype)
7487 
      else:
7488 
        iprot.skip(ftype)
7489 
      iprot.readFieldEnd()
7490 
    iprot.readStructEnd()
7491 
 
7492 
  def write(self, oprot):
7493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7495 
      return
7496 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7497 
    if self.success is not None:
3427 chandransh 7498 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7499 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7500 
      for iter69 in self.success:
7501 
        iter69.write(oprot)
3427 chandransh 7502 
      oprot.writeListEnd()
7503 
      oprot.writeFieldEnd()
3431 rajveer 7504 
    if self.ex is not None:
3427 chandransh 7505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7506 
      self.ex.write(oprot)
7507 
      oprot.writeFieldEnd()
7508 
    oprot.writeFieldStop()
7509 
    oprot.writeStructEnd()
7510 
 
3431 rajveer 7511 
  def validate(self):
7512 
    return
7513 
 
7514 
 
3427 chandransh 7515 
  def __repr__(self):
7516 
    L = ['%s=%r' % (key, value)
7517 
      for key, value in self.__dict__.iteritems()]
7518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7519 
 
7520 
  def __eq__(self, other):
7521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7522 
 
7523 
  def __ne__(self, other):
7524 
    return not (self == other)
7525 
 
1382 varun.gupt 7526 
class getReturnableOrdersForCustomer_args:
7527 
  """
7528 
  Attributes:
7529 
   - customer_id
7530 
   - limit
7531 
  """
7532 
 
7533 
  thrift_spec = (
7534 
    None, # 0
7535 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7536 
    (2, TType.I64, 'limit', None, None, ), # 2
7537 
  )
7538 
 
7539 
  def __init__(self, customer_id=None, limit=None,):
7540 
    self.customer_id = customer_id
7541 
    self.limit = limit
7542 
 
7543 
  def read(self, iprot):
7544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7546 
      return
7547 
    iprot.readStructBegin()
7548 
    while True:
7549 
      (fname, ftype, fid) = iprot.readFieldBegin()
7550 
      if ftype == TType.STOP:
7551 
        break
7552 
      if fid == 1:
7553 
        if ftype == TType.I64:
7554 
          self.customer_id = iprot.readI64();
7555 
        else:
7556 
          iprot.skip(ftype)
7557 
      elif fid == 2:
7558 
        if ftype == TType.I64:
7559 
          self.limit = iprot.readI64();
7560 
        else:
7561 
          iprot.skip(ftype)
7562 
      else:
7563 
        iprot.skip(ftype)
7564 
      iprot.readFieldEnd()
7565 
    iprot.readStructEnd()
7566 
 
7567 
  def write(self, oprot):
7568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7570 
      return
7571 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7572 
    if self.customer_id is not None:
1382 varun.gupt 7573 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7574 
      oprot.writeI64(self.customer_id)
7575 
      oprot.writeFieldEnd()
3431 rajveer 7576 
    if self.limit is not None:
1382 varun.gupt 7577 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7578 
      oprot.writeI64(self.limit)
7579 
      oprot.writeFieldEnd()
7580 
    oprot.writeFieldStop()
7581 
    oprot.writeStructEnd()
7582 
 
3431 rajveer 7583 
  def validate(self):
7584 
    return
7585 
 
7586 
 
1382 varun.gupt 7587 
  def __repr__(self):
7588 
    L = ['%s=%r' % (key, value)
7589 
      for key, value in self.__dict__.iteritems()]
7590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7591 
 
7592 
  def __eq__(self, other):
7593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7594 
 
7595 
  def __ne__(self, other):
7596 
    return not (self == other)
7597 
 
7598 
class getReturnableOrdersForCustomer_result:
7599 
  """
7600 
  Attributes:
7601 
   - success
7602 
   - ex
7603 
  """
7604 
 
7605 
  thrift_spec = (
7606 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7608 
  )
7609 
 
7610 
  def __init__(self, success=None, ex=None,):
7611 
    self.success = success
7612 
    self.ex = ex
7613 
 
7614 
  def read(self, iprot):
7615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7617 
      return
7618 
    iprot.readStructBegin()
7619 
    while True:
7620 
      (fname, ftype, fid) = iprot.readFieldBegin()
7621 
      if ftype == TType.STOP:
7622 
        break
7623 
      if fid == 0:
7624 
        if ftype == TType.LIST:
7625 
          self.success = []
4133 chandransh 7626 
          (_etype73, _size70) = iprot.readListBegin()
7627 
          for _i74 in xrange(_size70):
7628 
            _elem75 = iprot.readI64();
7629 
            self.success.append(_elem75)
1382 varun.gupt 7630 
          iprot.readListEnd()
7631 
        else:
7632 
          iprot.skip(ftype)
7633 
      elif fid == 1:
7634 
        if ftype == TType.STRUCT:
7635 
          self.ex = TransactionServiceException()
7636 
          self.ex.read(iprot)
7637 
        else:
7638 
          iprot.skip(ftype)
7639 
      else:
7640 
        iprot.skip(ftype)
7641 
      iprot.readFieldEnd()
7642 
    iprot.readStructEnd()
7643 
 
7644 
  def write(self, oprot):
7645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7647 
      return
7648 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7649 
    if self.success is not None:
1382 varun.gupt 7650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7651 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7652 
      for iter76 in self.success:
7653 
        oprot.writeI64(iter76)
1382 varun.gupt 7654 
      oprot.writeListEnd()
7655 
      oprot.writeFieldEnd()
3431 rajveer 7656 
    if self.ex is not None:
1382 varun.gupt 7657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7658 
      self.ex.write(oprot)
7659 
      oprot.writeFieldEnd()
7660 
    oprot.writeFieldStop()
7661 
    oprot.writeStructEnd()
7662 
 
3431 rajveer 7663 
  def validate(self):
7664 
    return
7665 
 
7666 
 
1382 varun.gupt 7667 
  def __repr__(self):
7668 
    L = ['%s=%r' % (key, value)
7669 
      for key, value in self.__dict__.iteritems()]
7670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7671 
 
7672 
  def __eq__(self, other):
7673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7674 
 
7675 
  def __ne__(self, other):
7676 
    return not (self == other)
7677 
 
7678 
class getCancellableOrdersForCustomer_args:
7679 
  """
7680 
  Attributes:
7681 
   - customer_id
7682 
   - limit
7683 
  """
7684 
 
7685 
  thrift_spec = (
7686 
    None, # 0
7687 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7688 
    (2, TType.I64, 'limit', None, None, ), # 2
7689 
  )
7690 
 
7691 
  def __init__(self, customer_id=None, limit=None,):
7692 
    self.customer_id = customer_id
7693 
    self.limit = limit
7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 1:
7705 
        if ftype == TType.I64:
7706 
          self.customer_id = iprot.readI64();
7707 
        else:
7708 
          iprot.skip(ftype)
7709 
      elif fid == 2:
7710 
        if ftype == TType.I64:
7711 
          self.limit = iprot.readI64();
7712 
        else:
7713 
          iprot.skip(ftype)
7714 
      else:
7715 
        iprot.skip(ftype)
7716 
      iprot.readFieldEnd()
7717 
    iprot.readStructEnd()
7718 
 
7719 
  def write(self, oprot):
7720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7722 
      return
7723 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7724 
    if self.customer_id is not None:
1382 varun.gupt 7725 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7726 
      oprot.writeI64(self.customer_id)
7727 
      oprot.writeFieldEnd()
3431 rajveer 7728 
    if self.limit is not None:
1382 varun.gupt 7729 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7730 
      oprot.writeI64(self.limit)
7731 
      oprot.writeFieldEnd()
7732 
    oprot.writeFieldStop()
7733 
    oprot.writeStructEnd()
7734 
 
3431 rajveer 7735 
  def validate(self):
7736 
    return
7737 
 
7738 
 
1382 varun.gupt 7739 
  def __repr__(self):
7740 
    L = ['%s=%r' % (key, value)
7741 
      for key, value in self.__dict__.iteritems()]
7742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7743 
 
7744 
  def __eq__(self, other):
7745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7746 
 
7747 
  def __ne__(self, other):
7748 
    return not (self == other)
7749 
 
7750 
class getCancellableOrdersForCustomer_result:
7751 
  """
7752 
  Attributes:
7753 
   - success
7754 
   - ex
7755 
  """
7756 
 
7757 
  thrift_spec = (
7758 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7760 
  )
7761 
 
7762 
  def __init__(self, success=None, ex=None,):
7763 
    self.success = success
7764 
    self.ex = ex
7765 
 
7766 
  def read(self, iprot):
7767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7769 
      return
7770 
    iprot.readStructBegin()
7771 
    while True:
7772 
      (fname, ftype, fid) = iprot.readFieldBegin()
7773 
      if ftype == TType.STOP:
7774 
        break
7775 
      if fid == 0:
7776 
        if ftype == TType.LIST:
7777 
          self.success = []
4133 chandransh 7778 
          (_etype80, _size77) = iprot.readListBegin()
7779 
          for _i81 in xrange(_size77):
7780 
            _elem82 = iprot.readI64();
7781 
            self.success.append(_elem82)
1382 varun.gupt 7782 
          iprot.readListEnd()
7783 
        else:
7784 
          iprot.skip(ftype)
7785 
      elif fid == 1:
7786 
        if ftype == TType.STRUCT:
7787 
          self.ex = TransactionServiceException()
7788 
          self.ex.read(iprot)
7789 
        else:
7790 
          iprot.skip(ftype)
7791 
      else:
7792 
        iprot.skip(ftype)
7793 
      iprot.readFieldEnd()
7794 
    iprot.readStructEnd()
7795 
 
7796 
  def write(self, oprot):
7797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7799 
      return
7800 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7801 
    if self.success is not None:
1382 varun.gupt 7802 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7803 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7804 
      for iter83 in self.success:
7805 
        oprot.writeI64(iter83)
1382 varun.gupt 7806 
      oprot.writeListEnd()
7807 
      oprot.writeFieldEnd()
3431 rajveer 7808 
    if self.ex is not None:
1382 varun.gupt 7809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7810 
      self.ex.write(oprot)
7811 
      oprot.writeFieldEnd()
7812 
    oprot.writeFieldStop()
7813 
    oprot.writeStructEnd()
7814 
 
3431 rajveer 7815 
  def validate(self):
7816 
    return
7817 
 
7818 
 
1382 varun.gupt 7819 
  def __repr__(self):
7820 
    L = ['%s=%r' % (key, value)
7821 
      for key, value in self.__dict__.iteritems()]
7822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7823 
 
7824 
  def __eq__(self, other):
7825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7826 
 
7827 
  def __ne__(self, other):
7828 
    return not (self == other)
7829 
 
483 rajveer 7830 
class changeOrderStatus_args:
94 ashish 7831 
  """
7832 
  Attributes:
483 rajveer 7833 
   - orderId
7834 
   - status
7835 
   - description
94 ashish 7836 
  """
7837 
 
7838 
  thrift_spec = (
7839 
    None, # 0
483 rajveer 7840 
    (1, TType.I64, 'orderId', None, None, ), # 1
7841 
    (2, TType.I32, 'status', None, None, ), # 2
7842 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7843 
  )
7844 
 
483 rajveer 7845 
  def __init__(self, orderId=None, status=None, description=None,):
7846 
    self.orderId = orderId
7847 
    self.status = status
7848 
    self.description = description
94 ashish 7849 
 
7850 
  def read(self, iprot):
7851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7853 
      return
7854 
    iprot.readStructBegin()
7855 
    while True:
7856 
      (fname, ftype, fid) = iprot.readFieldBegin()
7857 
      if ftype == TType.STOP:
7858 
        break
7859 
      if fid == 1:
7860 
        if ftype == TType.I64:
483 rajveer 7861 
          self.orderId = iprot.readI64();
94 ashish 7862 
        else:
7863 
          iprot.skip(ftype)
7864 
      elif fid == 2:
483 rajveer 7865 
        if ftype == TType.I32:
7866 
          self.status = iprot.readI32();
94 ashish 7867 
        else:
7868 
          iprot.skip(ftype)
483 rajveer 7869 
      elif fid == 3:
7870 
        if ftype == TType.STRING:
7871 
          self.description = iprot.readString();
7872 
        else:
7873 
          iprot.skip(ftype)
94 ashish 7874 
      else:
7875 
        iprot.skip(ftype)
7876 
      iprot.readFieldEnd()
7877 
    iprot.readStructEnd()
7878 
 
7879 
  def write(self, oprot):
7880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7882 
      return
483 rajveer 7883 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7884 
    if self.orderId is not None:
483 rajveer 7885 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7886 
      oprot.writeI64(self.orderId)
94 ashish 7887 
      oprot.writeFieldEnd()
3431 rajveer 7888 
    if self.status is not None:
483 rajveer 7889 
      oprot.writeFieldBegin('status', TType.I32, 2)
7890 
      oprot.writeI32(self.status)
94 ashish 7891 
      oprot.writeFieldEnd()
3431 rajveer 7892 
    if self.description is not None:
483 rajveer 7893 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7894 
      oprot.writeString(self.description)
7895 
      oprot.writeFieldEnd()
94 ashish 7896 
    oprot.writeFieldStop()
7897 
    oprot.writeStructEnd()
7898 
 
3431 rajveer 7899 
  def validate(self):
7900 
    return
7901 
 
7902 
 
94 ashish 7903 
  def __repr__(self):
7904 
    L = ['%s=%r' % (key, value)
7905 
      for key, value in self.__dict__.iteritems()]
7906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7907 
 
7908 
  def __eq__(self, other):
7909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7910 
 
7911 
  def __ne__(self, other):
7912 
    return not (self == other)
7913 
 
483 rajveer 7914 
class changeOrderStatus_result:
94 ashish 7915 
  """
7916 
  Attributes:
7917 
   - success
7918 
   - ex
7919 
  """
7920 
 
7921 
  thrift_spec = (
7922 
    (0, TType.BOOL, 'success', None, None, ), # 0
7923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7924 
  )
7925 
 
7926 
  def __init__(self, success=None, ex=None,):
7927 
    self.success = success
7928 
    self.ex = ex
7929 
 
7930 
  def read(self, iprot):
7931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7933 
      return
7934 
    iprot.readStructBegin()
7935 
    while True:
7936 
      (fname, ftype, fid) = iprot.readFieldBegin()
7937 
      if ftype == TType.STOP:
7938 
        break
7939 
      if fid == 0:
7940 
        if ftype == TType.BOOL:
7941 
          self.success = iprot.readBool();
7942 
        else:
7943 
          iprot.skip(ftype)
7944 
      elif fid == 1:
7945 
        if ftype == TType.STRUCT:
7946 
          self.ex = TransactionServiceException()
7947 
          self.ex.read(iprot)
7948 
        else:
7949 
          iprot.skip(ftype)
7950 
      else:
7951 
        iprot.skip(ftype)
7952 
      iprot.readFieldEnd()
7953 
    iprot.readStructEnd()
7954 
 
7955 
  def write(self, oprot):
7956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7958 
      return
483 rajveer 7959 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7960 
    if self.success is not None:
94 ashish 7961 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7962 
      oprot.writeBool(self.success)
7963 
      oprot.writeFieldEnd()
3431 rajveer 7964 
    if self.ex is not None:
94 ashish 7965 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7966 
      self.ex.write(oprot)
7967 
      oprot.writeFieldEnd()
7968 
    oprot.writeFieldStop()
7969 
    oprot.writeStructEnd()
7970 
 
3431 rajveer 7971 
  def validate(self):
7972 
    return
7973 
 
7974 
 
94 ashish 7975 
  def __repr__(self):
7976 
    L = ['%s=%r' % (key, value)
7977 
      for key, value in self.__dict__.iteritems()]
7978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7979 
 
7980 
  def __eq__(self, other):
7981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7982 
 
7983 
  def __ne__(self, other):
7984 
    return not (self == other)
7985 
 
3064 chandransh 7986 
class getOrdersForTransaction_args:
494 rajveer 7987 
  """
7988 
  Attributes:
3064 chandransh 7989 
   - transactionId
7990 
   - customerId
494 rajveer 7991 
  """
7992 
 
7993 
  thrift_spec = (
7994 
    None, # 0
3064 chandransh 7995 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7996 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7997 
  )
7998 
 
3064 chandransh 7999 
  def __init__(self, transactionId=None, customerId=None,):
8000 
    self.transactionId = transactionId
8001 
    self.customerId = customerId
494 rajveer 8002 
 
8003 
  def read(self, iprot):
8004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8006 
      return
8007 
    iprot.readStructBegin()
8008 
    while True:
8009 
      (fname, ftype, fid) = iprot.readFieldBegin()
8010 
      if ftype == TType.STOP:
8011 
        break
8012 
      if fid == 1:
8013 
        if ftype == TType.I64:
3064 chandransh 8014 
          self.transactionId = iprot.readI64();
494 rajveer 8015 
        else:
8016 
          iprot.skip(ftype)
8017 
      elif fid == 2:
3064 chandransh 8018 
        if ftype == TType.I64:
8019 
          self.customerId = iprot.readI64();
494 rajveer 8020 
        else:
8021 
          iprot.skip(ftype)
8022 
      else:
8023 
        iprot.skip(ftype)
8024 
      iprot.readFieldEnd()
8025 
    iprot.readStructEnd()
8026 
 
8027 
  def write(self, oprot):
8028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8030 
      return
3064 chandransh 8031 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8032 
    if self.transactionId is not None:
3064 chandransh 8033 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8034 
      oprot.writeI64(self.transactionId)
494 rajveer 8035 
      oprot.writeFieldEnd()
3431 rajveer 8036 
    if self.customerId is not None:
3064 chandransh 8037 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8038 
      oprot.writeI64(self.customerId)
494 rajveer 8039 
      oprot.writeFieldEnd()
8040 
    oprot.writeFieldStop()
8041 
    oprot.writeStructEnd()
8042 
 
3431 rajveer 8043 
  def validate(self):
8044 
    return
8045 
 
8046 
 
494 rajveer 8047 
  def __repr__(self):
8048 
    L = ['%s=%r' % (key, value)
8049 
      for key, value in self.__dict__.iteritems()]
8050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8051 
 
8052 
  def __eq__(self, other):
8053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8054 
 
8055 
  def __ne__(self, other):
8056 
    return not (self == other)
8057 
 
3064 chandransh 8058 
class getOrdersForTransaction_result:
494 rajveer 8059 
  """
8060 
  Attributes:
8061 
   - success
8062 
   - ex
8063 
  """
8064 
 
8065 
  thrift_spec = (
3064 chandransh 8066 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8068 
  )
8069 
 
8070 
  def __init__(self, success=None, ex=None,):
8071 
    self.success = success
8072 
    self.ex = ex
8073 
 
8074 
  def read(self, iprot):
8075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8077 
      return
8078 
    iprot.readStructBegin()
8079 
    while True:
8080 
      (fname, ftype, fid) = iprot.readFieldBegin()
8081 
      if ftype == TType.STOP:
8082 
        break
8083 
      if fid == 0:
3064 chandransh 8084 
        if ftype == TType.LIST:
8085 
          self.success = []
4133 chandransh 8086 
          (_etype87, _size84) = iprot.readListBegin()
8087 
          for _i88 in xrange(_size84):
8088 
            _elem89 = Order()
8089 
            _elem89.read(iprot)
8090 
            self.success.append(_elem89)
3064 chandransh 8091 
          iprot.readListEnd()
494 rajveer 8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      elif fid == 1:
8095 
        if ftype == TType.STRUCT:
8096 
          self.ex = TransactionServiceException()
8097 
          self.ex.read(iprot)
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      else:
8101 
        iprot.skip(ftype)
8102 
      iprot.readFieldEnd()
8103 
    iprot.readStructEnd()
8104 
 
8105 
  def write(self, oprot):
8106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8108 
      return
3064 chandransh 8109 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8110 
    if self.success is not None:
3064 chandransh 8111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8112 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8113 
      for iter90 in self.success:
8114 
        iter90.write(oprot)
3064 chandransh 8115 
      oprot.writeListEnd()
494 rajveer 8116 
      oprot.writeFieldEnd()
3431 rajveer 8117 
    if self.ex is not None:
494 rajveer 8118 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8119 
      self.ex.write(oprot)
8120 
      oprot.writeFieldEnd()
8121 
    oprot.writeFieldStop()
8122 
    oprot.writeStructEnd()
8123 
 
3431 rajveer 8124 
  def validate(self):
8125 
    return
8126 
 
8127 
 
494 rajveer 8128 
  def __repr__(self):
8129 
    L = ['%s=%r' % (key, value)
8130 
      for key, value in self.__dict__.iteritems()]
8131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8132 
 
8133 
  def __eq__(self, other):
8134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8135 
 
8136 
  def __ne__(self, other):
8137 
    return not (self == other)
8138 
 
3064 chandransh 8139 
class getOrdersForCustomer_args:
1149 chandransh 8140 
  """
8141 
  Attributes:
3064 chandransh 8142 
   - customerId
8143 
   - from_date
8144 
   - to_date
8145 
   - statuses
1149 chandransh 8146 
  """
8147 
 
8148 
  thrift_spec = (
8149 
    None, # 0
3064 chandransh 8150 
    (1, TType.I64, 'customerId', None, None, ), # 1
8151 
    (2, TType.I64, 'from_date', None, None, ), # 2
8152 
    (3, TType.I64, 'to_date', None, None, ), # 3
8153 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8154 
  )
8155 
 
3064 chandransh 8156 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8157 
    self.customerId = customerId
8158 
    self.from_date = from_date
8159 
    self.to_date = to_date
8160 
    self.statuses = statuses
1149 chandransh 8161 
 
8162 
  def read(self, iprot):
8163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8165 
      return
8166 
    iprot.readStructBegin()
8167 
    while True:
8168 
      (fname, ftype, fid) = iprot.readFieldBegin()
8169 
      if ftype == TType.STOP:
8170 
        break
8171 
      if fid == 1:
8172 
        if ftype == TType.I64:
3064 chandransh 8173 
          self.customerId = iprot.readI64();
1149 chandransh 8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      elif fid == 2:
8177 
        if ftype == TType.I64:
3064 chandransh 8178 
          self.from_date = iprot.readI64();
1149 chandransh 8179 
        else:
8180 
          iprot.skip(ftype)
2783 chandransh 8181 
      elif fid == 3:
8182 
        if ftype == TType.I64:
3064 chandransh 8183 
          self.to_date = iprot.readI64();
2783 chandransh 8184 
        else:
8185 
          iprot.skip(ftype)
8186 
      elif fid == 4:
3064 chandransh 8187 
        if ftype == TType.LIST:
8188 
          self.statuses = []
4133 chandransh 8189 
          (_etype94, _size91) = iprot.readListBegin()
8190 
          for _i95 in xrange(_size91):
8191 
            _elem96 = iprot.readI32();
8192 
            self.statuses.append(_elem96)
3064 chandransh 8193 
          iprot.readListEnd()
2783 chandransh 8194 
        else:
8195 
          iprot.skip(ftype)
1149 chandransh 8196 
      else:
8197 
        iprot.skip(ftype)
8198 
      iprot.readFieldEnd()
8199 
    iprot.readStructEnd()
8200 
 
8201 
  def write(self, oprot):
8202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8204 
      return
3064 chandransh 8205 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8206 
    if self.customerId is not None:
3064 chandransh 8207 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8208 
      oprot.writeI64(self.customerId)
1149 chandransh 8209 
      oprot.writeFieldEnd()
3431 rajveer 8210 
    if self.from_date is not None:
3064 chandransh 8211 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8212 
      oprot.writeI64(self.from_date)
1149 chandransh 8213 
      oprot.writeFieldEnd()
3431 rajveer 8214 
    if self.to_date is not None:
3064 chandransh 8215 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8216 
      oprot.writeI64(self.to_date)
2783 chandransh 8217 
      oprot.writeFieldEnd()
3431 rajveer 8218 
    if self.statuses is not None:
3064 chandransh 8219 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8220 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8221 
      for iter97 in self.statuses:
8222 
        oprot.writeI32(iter97)
3064 chandransh 8223 
      oprot.writeListEnd()
2783 chandransh 8224 
      oprot.writeFieldEnd()
1149 chandransh 8225 
    oprot.writeFieldStop()
8226 
    oprot.writeStructEnd()
8227 
 
3431 rajveer 8228 
  def validate(self):
8229 
    return
8230 
 
8231 
 
1149 chandransh 8232 
  def __repr__(self):
8233 
    L = ['%s=%r' % (key, value)
8234 
      for key, value in self.__dict__.iteritems()]
8235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8236 
 
8237 
  def __eq__(self, other):
8238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8239 
 
8240 
  def __ne__(self, other):
8241 
    return not (self == other)
8242 
 
3064 chandransh 8243 
class getOrdersForCustomer_result:
1149 chandransh 8244 
  """
8245 
  Attributes:
8246 
   - success
8247 
   - ex
8248 
  """
8249 
 
8250 
  thrift_spec = (
3064 chandransh 8251 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8252 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8253 
  )
8254 
 
8255 
  def __init__(self, success=None, ex=None,):
8256 
    self.success = success
8257 
    self.ex = ex
8258 
 
8259 
  def read(self, iprot):
8260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8262 
      return
8263 
    iprot.readStructBegin()
8264 
    while True:
8265 
      (fname, ftype, fid) = iprot.readFieldBegin()
8266 
      if ftype == TType.STOP:
8267 
        break
8268 
      if fid == 0:
3064 chandransh 8269 
        if ftype == TType.LIST:
8270 
          self.success = []
4133 chandransh 8271 
          (_etype101, _size98) = iprot.readListBegin()
8272 
          for _i102 in xrange(_size98):
8273 
            _elem103 = Order()
8274 
            _elem103.read(iprot)
8275 
            self.success.append(_elem103)
3064 chandransh 8276 
          iprot.readListEnd()
1149 chandransh 8277 
        else:
8278 
          iprot.skip(ftype)
8279 
      elif fid == 1:
8280 
        if ftype == TType.STRUCT:
8281 
          self.ex = TransactionServiceException()
8282 
          self.ex.read(iprot)
8283 
        else:
8284 
          iprot.skip(ftype)
8285 
      else:
8286 
        iprot.skip(ftype)
8287 
      iprot.readFieldEnd()
8288 
    iprot.readStructEnd()
8289 
 
8290 
  def write(self, oprot):
8291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8293 
      return
3064 chandransh 8294 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8295 
    if self.success is not None:
3064 chandransh 8296 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8297 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8298 
      for iter104 in self.success:
8299 
        iter104.write(oprot)
3064 chandransh 8300 
      oprot.writeListEnd()
1149 chandransh 8301 
      oprot.writeFieldEnd()
3431 rajveer 8302 
    if self.ex is not None:
1149 chandransh 8303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8304 
      self.ex.write(oprot)
8305 
      oprot.writeFieldEnd()
8306 
    oprot.writeFieldStop()
8307 
    oprot.writeStructEnd()
8308 
 
3431 rajveer 8309 
  def validate(self):
8310 
    return
8311 
 
8312 
 
1149 chandransh 8313 
  def __repr__(self):
8314 
    L = ['%s=%r' % (key, value)
8315 
      for key, value in self.__dict__.iteritems()]
8316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8317 
 
8318 
  def __eq__(self, other):
8319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8320 
 
8321 
  def __ne__(self, other):
8322 
    return not (self == other)
8323 
 
3064 chandransh 8324 
class createOrder_args:
921 rajveer 8325 
  """
8326 
  Attributes:
3064 chandransh 8327 
   - order
921 rajveer 8328 
  """
8329 
 
8330 
  thrift_spec = (
8331 
    None, # 0
3064 chandransh 8332 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8333 
  )
8334 
 
3064 chandransh 8335 
  def __init__(self, order=None,):
8336 
    self.order = order
921 rajveer 8337 
 
8338 
  def read(self, iprot):
8339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8341 
      return
8342 
    iprot.readStructBegin()
8343 
    while True:
8344 
      (fname, ftype, fid) = iprot.readFieldBegin()
8345 
      if ftype == TType.STOP:
8346 
        break
8347 
      if fid == 1:
3064 chandransh 8348 
        if ftype == TType.STRUCT:
8349 
          self.order = Order()
8350 
          self.order.read(iprot)
921 rajveer 8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      else:
8354 
        iprot.skip(ftype)
8355 
      iprot.readFieldEnd()
8356 
    iprot.readStructEnd()
8357 
 
8358 
  def write(self, oprot):
8359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8361 
      return
3064 chandransh 8362 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8363 
    if self.order is not None:
3064 chandransh 8364 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8365 
      self.order.write(oprot)
921 rajveer 8366 
      oprot.writeFieldEnd()
8367 
    oprot.writeFieldStop()
8368 
    oprot.writeStructEnd()
8369 
 
3431 rajveer 8370 
  def validate(self):
8371 
    return
8372 
 
8373 
 
921 rajveer 8374 
  def __repr__(self):
8375 
    L = ['%s=%r' % (key, value)
8376 
      for key, value in self.__dict__.iteritems()]
8377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8378 
 
8379 
  def __eq__(self, other):
8380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8381 
 
8382 
  def __ne__(self, other):
8383 
    return not (self == other)
8384 
 
3064 chandransh 8385 
class createOrder_result:
921 rajveer 8386 
  """
8387 
  Attributes:
8388 
   - success
8389 
   - ex
8390 
  """
8391 
 
8392 
  thrift_spec = (
3064 chandransh 8393 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8395 
  )
8396 
 
8397 
  def __init__(self, success=None, ex=None,):
8398 
    self.success = success
8399 
    self.ex = ex
8400 
 
8401 
  def read(self, iprot):
8402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8404 
      return
8405 
    iprot.readStructBegin()
8406 
    while True:
8407 
      (fname, ftype, fid) = iprot.readFieldBegin()
8408 
      if ftype == TType.STOP:
8409 
        break
8410 
      if fid == 0:
3064 chandransh 8411 
        if ftype == TType.I64:
8412 
          self.success = iprot.readI64();
921 rajveer 8413 
        else:
8414 
          iprot.skip(ftype)
8415 
      elif fid == 1:
8416 
        if ftype == TType.STRUCT:
8417 
          self.ex = TransactionServiceException()
8418 
          self.ex.read(iprot)
8419 
        else:
8420 
          iprot.skip(ftype)
8421 
      else:
8422 
        iprot.skip(ftype)
8423 
      iprot.readFieldEnd()
8424 
    iprot.readStructEnd()
8425 
 
8426 
  def write(self, oprot):
8427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8429 
      return
3064 chandransh 8430 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8431 
    if self.success is not None:
3064 chandransh 8432 
      oprot.writeFieldBegin('success', TType.I64, 0)
8433 
      oprot.writeI64(self.success)
921 rajveer 8434 
      oprot.writeFieldEnd()
3431 rajveer 8435 
    if self.ex is not None:
921 rajveer 8436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8437 
      self.ex.write(oprot)
8438 
      oprot.writeFieldEnd()
8439 
    oprot.writeFieldStop()
8440 
    oprot.writeStructEnd()
8441 
 
3431 rajveer 8442 
  def validate(self):
8443 
    return
8444 
 
8445 
 
921 rajveer 8446 
  def __repr__(self):
8447 
    L = ['%s=%r' % (key, value)
8448 
      for key, value in self.__dict__.iteritems()]
8449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8450 
 
8451 
  def __eq__(self, other):
8452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8453 
 
8454 
  def __ne__(self, other):
8455 
    return not (self == other)
8456 
 
3064 chandransh 8457 
class getOrder_args:
921 rajveer 8458 
  """
8459 
  Attributes:
3064 chandransh 8460 
   - id
921 rajveer 8461 
  """
8462 
 
8463 
  thrift_spec = (
8464 
    None, # 0
3064 chandransh 8465 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8466 
  )
8467 
 
3064 chandransh 8468 
  def __init__(self, id=None,):
8469 
    self.id = id
921 rajveer 8470 
 
8471 
  def read(self, iprot):
8472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8474 
      return
8475 
    iprot.readStructBegin()
8476 
    while True:
8477 
      (fname, ftype, fid) = iprot.readFieldBegin()
8478 
      if ftype == TType.STOP:
8479 
        break
8480 
      if fid == 1:
8481 
        if ftype == TType.I64:
3064 chandransh 8482 
          self.id = iprot.readI64();
921 rajveer 8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      else:
8486 
        iprot.skip(ftype)
8487 
      iprot.readFieldEnd()
8488 
    iprot.readStructEnd()
8489 
 
8490 
  def write(self, oprot):
8491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8493 
      return
3064 chandransh 8494 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8495 
    if self.id is not None:
3064 chandransh 8496 
      oprot.writeFieldBegin('id', TType.I64, 1)
8497 
      oprot.writeI64(self.id)
921 rajveer 8498 
      oprot.writeFieldEnd()
8499 
    oprot.writeFieldStop()
8500 
    oprot.writeStructEnd()
8501 
 
3431 rajveer 8502 
  def validate(self):
8503 
    return
8504 
 
8505 
 
921 rajveer 8506 
  def __repr__(self):
8507 
    L = ['%s=%r' % (key, value)
8508 
      for key, value in self.__dict__.iteritems()]
8509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8510 
 
8511 
  def __eq__(self, other):
8512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8513 
 
8514 
  def __ne__(self, other):
8515 
    return not (self == other)
8516 
 
3064 chandransh 8517 
class getOrder_result:
921 rajveer 8518 
  """
8519 
  Attributes:
8520 
   - success
8521 
   - ex
8522 
  """
8523 
 
8524 
  thrift_spec = (
3064 chandransh 8525 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8527 
  )
8528 
 
8529 
  def __init__(self, success=None, ex=None,):
8530 
    self.success = success
8531 
    self.ex = ex
8532 
 
8533 
  def read(self, iprot):
8534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8536 
      return
8537 
    iprot.readStructBegin()
8538 
    while True:
8539 
      (fname, ftype, fid) = iprot.readFieldBegin()
8540 
      if ftype == TType.STOP:
8541 
        break
8542 
      if fid == 0:
3064 chandransh 8543 
        if ftype == TType.STRUCT:
8544 
          self.success = Order()
8545 
          self.success.read(iprot)
921 rajveer 8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      elif fid == 1:
8549 
        if ftype == TType.STRUCT:
8550 
          self.ex = TransactionServiceException()
8551 
          self.ex.read(iprot)
8552 
        else:
8553 
          iprot.skip(ftype)
8554 
      else:
8555 
        iprot.skip(ftype)
8556 
      iprot.readFieldEnd()
8557 
    iprot.readStructEnd()
8558 
 
8559 
  def write(self, oprot):
8560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8562 
      return
3064 chandransh 8563 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8564 
    if self.success is not None:
3064 chandransh 8565 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8566 
      self.success.write(oprot)
921 rajveer 8567 
      oprot.writeFieldEnd()
3431 rajveer 8568 
    if self.ex is not None:
921 rajveer 8569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8570 
      self.ex.write(oprot)
8571 
      oprot.writeFieldEnd()
8572 
    oprot.writeFieldStop()
8573 
    oprot.writeStructEnd()
8574 
 
3431 rajveer 8575 
  def validate(self):
8576 
    return
8577 
 
8578 
 
921 rajveer 8579 
  def __repr__(self):
8580 
    L = ['%s=%r' % (key, value)
8581 
      for key, value in self.__dict__.iteritems()]
8582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8583 
 
8584 
  def __eq__(self, other):
8585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8586 
 
8587 
  def __ne__(self, other):
8588 
    return not (self == other)
8589 
 
3064 chandransh 8590 
class getLineItemsForOrder_args:
94 ashish 8591 
  """
8592 
  Attributes:
3064 chandransh 8593 
   - orderId
94 ashish 8594 
  """
8595 
 
8596 
  thrift_spec = (
8597 
    None, # 0
3064 chandransh 8598 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8599 
  )
8600 
 
3064 chandransh 8601 
  def __init__(self, orderId=None,):
8602 
    self.orderId = orderId
94 ashish 8603 
 
8604 
  def read(self, iprot):
8605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8607 
      return
8608 
    iprot.readStructBegin()
8609 
    while True:
8610 
      (fname, ftype, fid) = iprot.readFieldBegin()
8611 
      if ftype == TType.STOP:
8612 
        break
8613 
      if fid == 1:
8614 
        if ftype == TType.I64:
3064 chandransh 8615 
          self.orderId = iprot.readI64();
94 ashish 8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
3064 chandransh 8627 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8628 
    if self.orderId is not None:
3064 chandransh 8629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8630 
      oprot.writeI64(self.orderId)
94 ashish 8631 
      oprot.writeFieldEnd()
8632 
    oprot.writeFieldStop()
8633 
    oprot.writeStructEnd()
8634 
 
3431 rajveer 8635 
  def validate(self):
8636 
    return
8637 
 
8638 
 
94 ashish 8639 
  def __repr__(self):
8640 
    L = ['%s=%r' % (key, value)
8641 
      for key, value in self.__dict__.iteritems()]
8642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8643 
 
8644 
  def __eq__(self, other):
8645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8646 
 
8647 
  def __ne__(self, other):
8648 
    return not (self == other)
8649 
 
3064 chandransh 8650 
class getLineItemsForOrder_result:
94 ashish 8651 
  """
8652 
  Attributes:
8653 
   - success
8654 
   - ex
8655 
  """
8656 
 
8657 
  thrift_spec = (
3064 chandransh 8658 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8660 
  )
8661 
 
8662 
  def __init__(self, success=None, ex=None,):
8663 
    self.success = success
8664 
    self.ex = ex
8665 
 
8666 
  def read(self, iprot):
8667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8669 
      return
8670 
    iprot.readStructBegin()
8671 
    while True:
8672 
      (fname, ftype, fid) = iprot.readFieldBegin()
8673 
      if ftype == TType.STOP:
8674 
        break
8675 
      if fid == 0:
483 rajveer 8676 
        if ftype == TType.LIST:
8677 
          self.success = []
4133 chandransh 8678 
          (_etype108, _size105) = iprot.readListBegin()
8679 
          for _i109 in xrange(_size105):
8680 
            _elem110 = LineItem()
8681 
            _elem110.read(iprot)
8682 
            self.success.append(_elem110)
483 rajveer 8683 
          iprot.readListEnd()
94 ashish 8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      elif fid == 1:
8687 
        if ftype == TType.STRUCT:
8688 
          self.ex = TransactionServiceException()
8689 
          self.ex.read(iprot)
8690 
        else:
8691 
          iprot.skip(ftype)
8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
3064 chandransh 8701 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8702 
    if self.success is not None:
483 rajveer 8703 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8704 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8705 
      for iter111 in self.success:
8706 
        iter111.write(oprot)
483 rajveer 8707 
      oprot.writeListEnd()
94 ashish 8708 
      oprot.writeFieldEnd()
3431 rajveer 8709 
    if self.ex is not None:
94 ashish 8710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8711 
      self.ex.write(oprot)
8712 
      oprot.writeFieldEnd()
8713 
    oprot.writeFieldStop()
8714 
    oprot.writeStructEnd()
8715 
 
3431 rajveer 8716 
  def validate(self):
8717 
    return
8718 
 
8719 
 
94 ashish 8720 
  def __repr__(self):
8721 
    L = ['%s=%r' % (key, value)
8722 
      for key, value in self.__dict__.iteritems()]
8723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8724 
 
8725 
  def __eq__(self, other):
8726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8727 
 
8728 
  def __ne__(self, other):
8729 
    return not (self == other)
8730 
 
3064 chandransh 8731 
class getOrderForCustomer_args:
94 ashish 8732 
  """
8733 
  Attributes:
3064 chandransh 8734 
   - orderId
483 rajveer 8735 
   - customerId
94 ashish 8736 
  """
8737 
 
8738 
  thrift_spec = (
8739 
    None, # 0
3064 chandransh 8740 
    (1, TType.I64, 'orderId', None, None, ), # 1
8741 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8742 
  )
8743 
 
3064 chandransh 8744 
  def __init__(self, orderId=None, customerId=None,):
8745 
    self.orderId = orderId
483 rajveer 8746 
    self.customerId = customerId
94 ashish 8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 1:
8758 
        if ftype == TType.I64:
3064 chandransh 8759 
          self.orderId = iprot.readI64();
94 ashish 8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      elif fid == 2:
8763 
        if ftype == TType.I64:
3064 chandransh 8764 
          self.customerId = iprot.readI64();
94 ashish 8765 
        else:
8766 
          iprot.skip(ftype)
8767 
      else:
8768 
        iprot.skip(ftype)
8769 
      iprot.readFieldEnd()
8770 
    iprot.readStructEnd()
8771 
 
8772 
  def write(self, oprot):
8773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8775 
      return
3064 chandransh 8776 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8777 
    if self.orderId is not None:
3064 chandransh 8778 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8779 
      oprot.writeI64(self.orderId)
8780 
      oprot.writeFieldEnd()
3431 rajveer 8781 
    if self.customerId is not None:
3064 chandransh 8782 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8783 
      oprot.writeI64(self.customerId)
94 ashish 8784 
      oprot.writeFieldEnd()
8785 
    oprot.writeFieldStop()
8786 
    oprot.writeStructEnd()
8787 
 
3431 rajveer 8788 
  def validate(self):
8789 
    return
8790 
 
8791 
 
94 ashish 8792 
  def __repr__(self):
8793 
    L = ['%s=%r' % (key, value)
8794 
      for key, value in self.__dict__.iteritems()]
8795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8796 
 
8797 
  def __eq__(self, other):
8798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8799 
 
8800 
  def __ne__(self, other):
8801 
    return not (self == other)
8802 
 
3064 chandransh 8803 
class getOrderForCustomer_result:
94 ashish 8804 
  """
8805 
  Attributes:
8806 
   - success
8807 
   - ex
8808 
  """
8809 
 
8810 
  thrift_spec = (
3064 chandransh 8811 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8813 
  )
8814 
 
8815 
  def __init__(self, success=None, ex=None,):
8816 
    self.success = success
8817 
    self.ex = ex
8818 
 
8819 
  def read(self, iprot):
8820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8822 
      return
8823 
    iprot.readStructBegin()
8824 
    while True:
8825 
      (fname, ftype, fid) = iprot.readFieldBegin()
8826 
      if ftype == TType.STOP:
8827 
        break
8828 
      if fid == 0:
3064 chandransh 8829 
        if ftype == TType.STRUCT:
8830 
          self.success = Order()
8831 
          self.success.read(iprot)
94 ashish 8832 
        else:
8833 
          iprot.skip(ftype)
8834 
      elif fid == 1:
8835 
        if ftype == TType.STRUCT:
8836 
          self.ex = TransactionServiceException()
8837 
          self.ex.read(iprot)
8838 
        else:
8839 
          iprot.skip(ftype)
8840 
      else:
8841 
        iprot.skip(ftype)
8842 
      iprot.readFieldEnd()
8843 
    iprot.readStructEnd()
8844 
 
8845 
  def write(self, oprot):
8846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8848 
      return
3064 chandransh 8849 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8850 
    if self.success is not None:
3064 chandransh 8851 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8852 
      self.success.write(oprot)
94 ashish 8853 
      oprot.writeFieldEnd()
3431 rajveer 8854 
    if self.ex is not None:
94 ashish 8855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8856 
      self.ex.write(oprot)
8857 
      oprot.writeFieldEnd()
8858 
    oprot.writeFieldStop()
8859 
    oprot.writeStructEnd()
8860 
 
3431 rajveer 8861 
  def validate(self):
8862 
    return
8863 
 
8864 
 
94 ashish 8865 
  def __repr__(self):
8866 
    L = ['%s=%r' % (key, value)
8867 
      for key, value in self.__dict__.iteritems()]
8868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8869 
 
8870 
  def __eq__(self, other):
8871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8872 
 
8873 
  def __ne__(self, other):
8874 
    return not (self == other)
8875 
 
3064 chandransh 8876 
class getAlerts_args:
94 ashish 8877 
  """
8878 
  Attributes:
4394 rajveer 8879 
   - type
4444 rajveer 8880 
   - warehouseId
4394 rajveer 8881 
   - status
8882 
   - timestamp
94 ashish 8883 
  """
8884 
 
8885 
  thrift_spec = (
8886 
    None, # 0
4394 rajveer 8887 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8888 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8889 
    (3, TType.I64, 'status', None, None, ), # 3
8890 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8891 
  )
8892 
 
4444 rajveer 8893 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8894 
    self.type = type
4444 rajveer 8895 
    self.warehouseId = warehouseId
4394 rajveer 8896 
    self.status = status
8897 
    self.timestamp = timestamp
94 ashish 8898 
 
8899 
  def read(self, iprot):
8900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8902 
      return
8903 
    iprot.readStructBegin()
8904 
    while True:
8905 
      (fname, ftype, fid) = iprot.readFieldBegin()
8906 
      if ftype == TType.STOP:
8907 
        break
8908 
      if fid == 1:
3064 chandransh 8909 
        if ftype == TType.I64:
4394 rajveer 8910 
          self.type = iprot.readI64();
94 ashish 8911 
        else:
8912 
          iprot.skip(ftype)
3064 chandransh 8913 
      elif fid == 2:
4394 rajveer 8914 
        if ftype == TType.I64:
4444 rajveer 8915 
          self.warehouseId = iprot.readI64();
3064 chandransh 8916 
        else:
8917 
          iprot.skip(ftype)
4394 rajveer 8918 
      elif fid == 3:
8919 
        if ftype == TType.I64:
4444 rajveer 8920 
          self.status = iprot.readI64();
8921 
        else:
8922 
          iprot.skip(ftype)
8923 
      elif fid == 4:
8924 
        if ftype == TType.I64:
4394 rajveer 8925 
          self.timestamp = iprot.readI64();
8926 
        else:
8927 
          iprot.skip(ftype)
94 ashish 8928 
      else:
8929 
        iprot.skip(ftype)
8930 
      iprot.readFieldEnd()
8931 
    iprot.readStructEnd()
8932 
 
8933 
  def write(self, oprot):
8934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8936 
      return
3064 chandransh 8937 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8938 
    if self.type is not None:
8939 
      oprot.writeFieldBegin('type', TType.I64, 1)
8940 
      oprot.writeI64(self.type)
94 ashish 8941 
      oprot.writeFieldEnd()
4444 rajveer 8942 
    if self.warehouseId is not None:
8943 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8944 
      oprot.writeI64(self.warehouseId)
8945 
      oprot.writeFieldEnd()
4394 rajveer 8946 
    if self.status is not None:
4444 rajveer 8947 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8948 
      oprot.writeI64(self.status)
3064 chandransh 8949 
      oprot.writeFieldEnd()
4394 rajveer 8950 
    if self.timestamp is not None:
4444 rajveer 8951 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8952 
      oprot.writeI64(self.timestamp)
8953 
      oprot.writeFieldEnd()
94 ashish 8954 
    oprot.writeFieldStop()
8955 
    oprot.writeStructEnd()
8956 
 
3431 rajveer 8957 
  def validate(self):
8958 
    return
8959 
 
8960 
 
94 ashish 8961 
  def __repr__(self):
8962 
    L = ['%s=%r' % (key, value)
8963 
      for key, value in self.__dict__.iteritems()]
8964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8965 
 
8966 
  def __eq__(self, other):
8967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8968 
 
8969 
  def __ne__(self, other):
8970 
    return not (self == other)
8971 
 
3064 chandransh 8972 
class getAlerts_result:
94 ashish 8973 
  """
8974 
  Attributes:
8975 
   - success
8976 
  """
8977 
 
8978 
  thrift_spec = (
3064 chandransh 8979 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8980 
  )
8981 
 
3064 chandransh 8982 
  def __init__(self, success=None,):
94 ashish 8983 
    self.success = success
8984 
 
8985 
  def read(self, iprot):
8986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8988 
      return
8989 
    iprot.readStructBegin()
8990 
    while True:
8991 
      (fname, ftype, fid) = iprot.readFieldBegin()
8992 
      if ftype == TType.STOP:
8993 
        break
8994 
      if fid == 0:
3064 chandransh 8995 
        if ftype == TType.LIST:
8996 
          self.success = []
4133 chandransh 8997 
          (_etype115, _size112) = iprot.readListBegin()
8998 
          for _i116 in xrange(_size112):
8999 
            _elem117 = Alert()
9000 
            _elem117.read(iprot)
9001 
            self.success.append(_elem117)
3064 chandransh 9002 
          iprot.readListEnd()
94 ashish 9003 
        else:
9004 
          iprot.skip(ftype)
9005 
      else:
9006 
        iprot.skip(ftype)
9007 
      iprot.readFieldEnd()
9008 
    iprot.readStructEnd()
9009 
 
9010 
  def write(self, oprot):
9011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9013 
      return
3064 chandransh 9014 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9015 
    if self.success is not None:
3064 chandransh 9016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9018 
      for iter118 in self.success:
9019 
        iter118.write(oprot)
3064 chandransh 9020 
      oprot.writeListEnd()
94 ashish 9021 
      oprot.writeFieldEnd()
9022 
    oprot.writeFieldStop()
9023 
    oprot.writeStructEnd()
9024 
 
3431 rajveer 9025 
  def validate(self):
9026 
    return
9027 
 
9028 
 
94 ashish 9029 
  def __repr__(self):
9030 
    L = ['%s=%r' % (key, value)
9031 
      for key, value in self.__dict__.iteritems()]
9032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9033 
 
9034 
  def __eq__(self, other):
9035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9036 
 
9037 
  def __ne__(self, other):
9038 
    return not (self == other)
9039 
 
4394 rajveer 9040 
class addAlert_args:
94 ashish 9041 
  """
9042 
  Attributes:
3064 chandransh 9043 
   - type
4444 rajveer 9044 
   - warehouseId
4394 rajveer 9045 
   - description
94 ashish 9046 
  """
9047 
 
9048 
  thrift_spec = (
9049 
    None, # 0
4394 rajveer 9050 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9051 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9052 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9053 
  )
9054 
 
4444 rajveer 9055 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9056 
    self.type = type
4444 rajveer 9057 
    self.warehouseId = warehouseId
4394 rajveer 9058 
    self.description = description
94 ashish 9059 
 
9060 
  def read(self, iprot):
9061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9063 
      return
9064 
    iprot.readStructBegin()
9065 
    while True:
9066 
      (fname, ftype, fid) = iprot.readFieldBegin()
9067 
      if ftype == TType.STOP:
9068 
        break
9069 
      if fid == 1:
9070 
        if ftype == TType.I64:
4394 rajveer 9071 
          self.type = iprot.readI64();
94 ashish 9072 
        else:
9073 
          iprot.skip(ftype)
3064 chandransh 9074 
      elif fid == 2:
4444 rajveer 9075 
        if ftype == TType.I64:
9076 
          self.warehouseId = iprot.readI64();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      elif fid == 3:
3064 chandransh 9080 
        if ftype == TType.STRING:
4394 rajveer 9081 
          self.description = iprot.readString();
3064 chandransh 9082 
        else:
9083 
          iprot.skip(ftype)
94 ashish 9084 
      else:
9085 
        iprot.skip(ftype)
9086 
      iprot.readFieldEnd()
9087 
    iprot.readStructEnd()
9088 
 
9089 
  def write(self, oprot):
9090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9092 
      return
4394 rajveer 9093 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9094 
    if self.type is not None:
4394 rajveer 9095 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9096 
      oprot.writeI64(self.type)
9097 
      oprot.writeFieldEnd()
4444 rajveer 9098 
    if self.warehouseId is not None:
9099 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9100 
      oprot.writeI64(self.warehouseId)
9101 
      oprot.writeFieldEnd()
4394 rajveer 9102 
    if self.description is not None:
4444 rajveer 9103 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9104 
      oprot.writeString(self.description)
3064 chandransh 9105 
      oprot.writeFieldEnd()
94 ashish 9106 
    oprot.writeFieldStop()
9107 
    oprot.writeStructEnd()
9108 
 
3431 rajveer 9109 
  def validate(self):
9110 
    return
9111 
 
9112 
 
94 ashish 9113 
  def __repr__(self):
9114 
    L = ['%s=%r' % (key, value)
9115 
      for key, value in self.__dict__.iteritems()]
9116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9117 
 
9118 
  def __eq__(self, other):
9119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9120 
 
9121 
  def __ne__(self, other):
9122 
    return not (self == other)
9123 
 
4394 rajveer 9124 
class addAlert_result:
3064 chandransh 9125 
 
9126 
  thrift_spec = (
9127 
  )
9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      else:
9139 
        iprot.skip(ftype)
9140 
      iprot.readFieldEnd()
9141 
    iprot.readStructEnd()
9142 
 
9143 
  def write(self, oprot):
9144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9146 
      return
4394 rajveer 9147 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9148 
    oprot.writeFieldStop()
9149 
    oprot.writeStructEnd()
9150 
 
3431 rajveer 9151 
  def validate(self):
9152 
    return
9153 
 
9154 
 
3064 chandransh 9155 
  def __repr__(self):
9156 
    L = ['%s=%r' % (key, value)
9157 
      for key, value in self.__dict__.iteritems()]
9158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9159 
 
9160 
  def __eq__(self, other):
9161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9162 
 
9163 
  def __ne__(self, other):
9164 
    return not (self == other)
9165 
 
4444 rajveer 9166 
class markAlertsAsSeen_args:
9167 
  """
9168 
  Attributes:
9169 
   - warehouseId
9170 
  """
9171 
 
9172 
  thrift_spec = (
9173 
    None, # 0
9174 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9175 
  )
9176 
 
9177 
  def __init__(self, warehouseId=None,):
9178 
    self.warehouseId = warehouseId
9179 
 
9180 
  def read(self, iprot):
9181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9183 
      return
9184 
    iprot.readStructBegin()
9185 
    while True:
9186 
      (fname, ftype, fid) = iprot.readFieldBegin()
9187 
      if ftype == TType.STOP:
9188 
        break
9189 
      if fid == 1:
9190 
        if ftype == TType.I64:
9191 
          self.warehouseId = iprot.readI64();
9192 
        else:
9193 
          iprot.skip(ftype)
9194 
      else:
9195 
        iprot.skip(ftype)
9196 
      iprot.readFieldEnd()
9197 
    iprot.readStructEnd()
9198 
 
9199 
  def write(self, oprot):
9200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9202 
      return
9203 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9204 
    if self.warehouseId is not None:
9205 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9206 
      oprot.writeI64(self.warehouseId)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
9211 
  def validate(self):
9212 
    return
9213 
 
9214 
 
9215 
  def __repr__(self):
9216 
    L = ['%s=%r' % (key, value)
9217 
      for key, value in self.__dict__.iteritems()]
9218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9219 
 
9220 
  def __eq__(self, other):
9221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9222 
 
9223 
  def __ne__(self, other):
9224 
    return not (self == other)
9225 
 
9226 
class markAlertsAsSeen_result:
9227 
 
9228 
  thrift_spec = (
9229 
  )
9230 
 
9231 
  def read(self, iprot):
9232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9234 
      return
9235 
    iprot.readStructBegin()
9236 
    while True:
9237 
      (fname, ftype, fid) = iprot.readFieldBegin()
9238 
      if ftype == TType.STOP:
9239 
        break
9240 
      else:
9241 
        iprot.skip(ftype)
9242 
      iprot.readFieldEnd()
9243 
    iprot.readStructEnd()
9244 
 
9245 
  def write(self, oprot):
9246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9248 
      return
9249 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9250 
    oprot.writeFieldStop()
9251 
    oprot.writeStructEnd()
9252 
 
9253 
  def validate(self):
9254 
    return
9255 
 
9256 
 
9257 
  def __repr__(self):
9258 
    L = ['%s=%r' % (key, value)
9259 
      for key, value in self.__dict__.iteritems()]
9260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9261 
 
9262 
  def __eq__(self, other):
9263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9264 
 
9265 
  def __ne__(self, other):
9266 
    return not (self == other)
9267 
 
3064 chandransh 9268 
class getValidOrderCount_args:
9269 
 
9270 
  thrift_spec = (
9271 
  )
9272 
 
9273 
  def read(self, iprot):
9274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9276 
      return
9277 
    iprot.readStructBegin()
9278 
    while True:
9279 
      (fname, ftype, fid) = iprot.readFieldBegin()
9280 
      if ftype == TType.STOP:
9281 
        break
9282 
      else:
9283 
        iprot.skip(ftype)
9284 
      iprot.readFieldEnd()
9285 
    iprot.readStructEnd()
9286 
 
9287 
  def write(self, oprot):
9288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9290 
      return
9291 
    oprot.writeStructBegin('getValidOrderCount_args')
9292 
    oprot.writeFieldStop()
9293 
    oprot.writeStructEnd()
9294 
 
3431 rajveer 9295 
  def validate(self):
9296 
    return
9297 
 
9298 
 
3064 chandransh 9299 
  def __repr__(self):
9300 
    L = ['%s=%r' % (key, value)
9301 
      for key, value in self.__dict__.iteritems()]
9302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9303 
 
9304 
  def __eq__(self, other):
9305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9306 
 
9307 
  def __ne__(self, other):
9308 
    return not (self == other)
9309 
 
9310 
class getValidOrderCount_result:
94 ashish 9311 
  """
9312 
  Attributes:
9313 
   - success
9314 
  """
9315 
 
9316 
  thrift_spec = (
3064 chandransh 9317 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9318 
  )
9319 
 
3064 chandransh 9320 
  def __init__(self, success=None,):
94 ashish 9321 
    self.success = success
9322 
 
9323 
  def read(self, iprot):
9324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9326 
      return
9327 
    iprot.readStructBegin()
9328 
    while True:
9329 
      (fname, ftype, fid) = iprot.readFieldBegin()
9330 
      if ftype == TType.STOP:
9331 
        break
9332 
      if fid == 0:
3064 chandransh 9333 
        if ftype == TType.I64:
9334 
          self.success = iprot.readI64();
94 ashish 9335 
        else:
9336 
          iprot.skip(ftype)
9337 
      else:
9338 
        iprot.skip(ftype)
9339 
      iprot.readFieldEnd()
9340 
    iprot.readStructEnd()
9341 
 
9342 
  def write(self, oprot):
9343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9345 
      return
3064 chandransh 9346 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9347 
    if self.success is not None:
3064 chandransh 9348 
      oprot.writeFieldBegin('success', TType.I64, 0)
9349 
      oprot.writeI64(self.success)
94 ashish 9350 
      oprot.writeFieldEnd()
9351 
    oprot.writeFieldStop()
9352 
    oprot.writeStructEnd()
9353 
 
3431 rajveer 9354 
  def validate(self):
9355 
    return
9356 
 
9357 
 
94 ashish 9358 
  def __repr__(self):
9359 
    L = ['%s=%r' % (key, value)
9360 
      for key, value in self.__dict__.iteritems()]
9361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9362 
 
9363 
  def __eq__(self, other):
9364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9365 
 
9366 
  def __ne__(self, other):
9367 
    return not (self == other)
9368 
 
3064 chandransh 9369 
class getNoOfCustomersWithSuccessfulTransaction_args:
9370 
 
9371 
  thrift_spec = (
9372 
  )
9373 
 
9374 
  def read(self, iprot):
9375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9377 
      return
9378 
    iprot.readStructBegin()
9379 
    while True:
9380 
      (fname, ftype, fid) = iprot.readFieldBegin()
9381 
      if ftype == TType.STOP:
9382 
        break
9383 
      else:
9384 
        iprot.skip(ftype)
9385 
      iprot.readFieldEnd()
9386 
    iprot.readStructEnd()
9387 
 
9388 
  def write(self, oprot):
9389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9391 
      return
9392 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9393 
    oprot.writeFieldStop()
9394 
    oprot.writeStructEnd()
9395 
 
3431 rajveer 9396 
  def validate(self):
9397 
    return
9398 
 
9399 
 
3064 chandransh 9400 
  def __repr__(self):
9401 
    L = ['%s=%r' % (key, value)
9402 
      for key, value in self.__dict__.iteritems()]
9403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9404 
 
9405 
  def __eq__(self, other):
9406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9407 
 
9408 
  def __ne__(self, other):
9409 
    return not (self == other)
9410 
 
9411 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9412 
  """
9413 
  Attributes:
3064 chandransh 9414 
   - success
94 ashish 9415 
  """
9416 
 
9417 
  thrift_spec = (
3064 chandransh 9418 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9419 
  )
9420 
 
3064 chandransh 9421 
  def __init__(self, success=None,):
9422 
    self.success = success
94 ashish 9423 
 
9424 
  def read(self, iprot):
9425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9427 
      return
9428 
    iprot.readStructBegin()
9429 
    while True:
9430 
      (fname, ftype, fid) = iprot.readFieldBegin()
9431 
      if ftype == TType.STOP:
9432 
        break
3064 chandransh 9433 
      if fid == 0:
94 ashish 9434 
        if ftype == TType.I64:
3064 chandransh 9435 
          self.success = iprot.readI64();
94 ashish 9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      else:
9439 
        iprot.skip(ftype)
9440 
      iprot.readFieldEnd()
9441 
    iprot.readStructEnd()
9442 
 
9443 
  def write(self, oprot):
9444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9446 
      return
3064 chandransh 9447 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9448 
    if self.success is not None:
3064 chandransh 9449 
      oprot.writeFieldBegin('success', TType.I64, 0)
9450 
      oprot.writeI64(self.success)
94 ashish 9451 
      oprot.writeFieldEnd()
9452 
    oprot.writeFieldStop()
9453 
    oprot.writeStructEnd()
9454 
 
3431 rajveer 9455 
  def validate(self):
9456 
    return
9457 
 
9458 
 
94 ashish 9459 
  def __repr__(self):
9460 
    L = ['%s=%r' % (key, value)
9461 
      for key, value in self.__dict__.iteritems()]
9462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9463 
 
9464 
  def __eq__(self, other):
9465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9466 
 
9467 
  def __ne__(self, other):
9468 
    return not (self == other)
9469 
 
3064 chandransh 9470 
class getValidOrdersAmountRange_args:
9471 
 
9472 
  thrift_spec = (
9473 
  )
9474 
 
9475 
  def read(self, iprot):
9476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9478 
      return
9479 
    iprot.readStructBegin()
9480 
    while True:
9481 
      (fname, ftype, fid) = iprot.readFieldBegin()
9482 
      if ftype == TType.STOP:
9483 
        break
9484 
      else:
9485 
        iprot.skip(ftype)
9486 
      iprot.readFieldEnd()
9487 
    iprot.readStructEnd()
9488 
 
9489 
  def write(self, oprot):
9490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9492 
      return
9493 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9494 
    oprot.writeFieldStop()
9495 
    oprot.writeStructEnd()
9496 
 
3431 rajveer 9497 
  def validate(self):
9498 
    return
9499 
 
9500 
 
3064 chandransh 9501 
  def __repr__(self):
9502 
    L = ['%s=%r' % (key, value)
9503 
      for key, value in self.__dict__.iteritems()]
9504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9505 
 
9506 
  def __eq__(self, other):
9507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9508 
 
9509 
  def __ne__(self, other):
9510 
    return not (self == other)
9511 
 
9512 
class getValidOrdersAmountRange_result:
94 ashish 9513 
  """
9514 
  Attributes:
9515 
   - success
9516 
  """
9517 
 
9518 
  thrift_spec = (
3064 chandransh 9519 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9520 
  )
9521 
 
3064 chandransh 9522 
  def __init__(self, success=None,):
94 ashish 9523 
    self.success = success
9524 
 
9525 
  def read(self, iprot):
9526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9528 
      return
9529 
    iprot.readStructBegin()
9530 
    while True:
9531 
      (fname, ftype, fid) = iprot.readFieldBegin()
9532 
      if ftype == TType.STOP:
9533 
        break
9534 
      if fid == 0:
483 rajveer 9535 
        if ftype == TType.LIST:
9536 
          self.success = []
4133 chandransh 9537 
          (_etype122, _size119) = iprot.readListBegin()
9538 
          for _i123 in xrange(_size119):
9539 
            _elem124 = iprot.readDouble();
9540 
            self.success.append(_elem124)
483 rajveer 9541 
          iprot.readListEnd()
94 ashish 9542 
        else:
9543 
          iprot.skip(ftype)
9544 
      else:
9545 
        iprot.skip(ftype)
9546 
      iprot.readFieldEnd()
9547 
    iprot.readStructEnd()
9548 
 
9549 
  def write(self, oprot):
9550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9552 
      return
3064 chandransh 9553 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9554 
    if self.success is not None:
483 rajveer 9555 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9556 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9557 
      for iter125 in self.success:
9558 
        oprot.writeDouble(iter125)
483 rajveer 9559 
      oprot.writeListEnd()
94 ashish 9560 
      oprot.writeFieldEnd()
9561 
    oprot.writeFieldStop()
9562 
    oprot.writeStructEnd()
9563 
 
3431 rajveer 9564 
  def validate(self):
9565 
    return
9566 
 
9567 
 
94 ashish 9568 
  def __repr__(self):
9569 
    L = ['%s=%r' % (key, value)
9570 
      for key, value in self.__dict__.iteritems()]
9571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9572 
 
9573 
  def __eq__(self, other):
9574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9575 
 
9576 
  def __ne__(self, other):
9577 
    return not (self == other)
9578 
 
3064 chandransh 9579 
class getValidOrders_args:
1528 ankur.sing 9580 
  """
9581 
  Attributes:
3064 chandransh 9582 
   - limit
1528 ankur.sing 9583 
  """
9584 
 
9585 
  thrift_spec = (
9586 
    None, # 0
3064 chandransh 9587 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9588 
  )
9589 
 
3064 chandransh 9590 
  def __init__(self, limit=None,):
9591 
    self.limit = limit
1528 ankur.sing 9592 
 
9593 
  def read(self, iprot):
9594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9596 
      return
9597 
    iprot.readStructBegin()
9598 
    while True:
9599 
      (fname, ftype, fid) = iprot.readFieldBegin()
9600 
      if ftype == TType.STOP:
9601 
        break
9602 
      if fid == 1:
9603 
        if ftype == TType.I64:
3064 chandransh 9604 
          self.limit = iprot.readI64();
1528 ankur.sing 9605 
        else:
9606 
          iprot.skip(ftype)
9607 
      else:
9608 
        iprot.skip(ftype)
9609 
      iprot.readFieldEnd()
9610 
    iprot.readStructEnd()
9611 
 
9612 
  def write(self, oprot):
9613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9615 
      return
3064 chandransh 9616 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9617 
    if self.limit is not None:
3064 chandransh 9618 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9619 
      oprot.writeI64(self.limit)
1528 ankur.sing 9620 
      oprot.writeFieldEnd()
9621 
    oprot.writeFieldStop()
9622 
    oprot.writeStructEnd()
9623 
 
3431 rajveer 9624 
  def validate(self):
9625 
    return
9626 
 
9627 
 
1528 ankur.sing 9628 
  def __repr__(self):
9629 
    L = ['%s=%r' % (key, value)
9630 
      for key, value in self.__dict__.iteritems()]
9631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9632 
 
9633 
  def __eq__(self, other):
9634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9635 
 
9636 
  def __ne__(self, other):
9637 
    return not (self == other)
9638 
 
3064 chandransh 9639 
class getValidOrders_result:
1528 ankur.sing 9640 
  """
9641 
  Attributes:
9642 
   - success
9643 
  """
9644 
 
9645 
  thrift_spec = (
3064 chandransh 9646 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9647 
  )
9648 
 
3064 chandransh 9649 
  def __init__(self, success=None,):
1528 ankur.sing 9650 
    self.success = success
9651 
 
9652 
  def read(self, iprot):
9653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9655 
      return
9656 
    iprot.readStructBegin()
9657 
    while True:
9658 
      (fname, ftype, fid) = iprot.readFieldBegin()
9659 
      if ftype == TType.STOP:
9660 
        break
9661 
      if fid == 0:
3064 chandransh 9662 
        if ftype == TType.LIST:
9663 
          self.success = []
4133 chandransh 9664 
          (_etype129, _size126) = iprot.readListBegin()
9665 
          for _i130 in xrange(_size126):
9666 
            _elem131 = Order()
9667 
            _elem131.read(iprot)
9668 
            self.success.append(_elem131)
3064 chandransh 9669 
          iprot.readListEnd()
1528 ankur.sing 9670 
        else:
9671 
          iprot.skip(ftype)
9672 
      else:
9673 
        iprot.skip(ftype)
9674 
      iprot.readFieldEnd()
9675 
    iprot.readStructEnd()
9676 
 
9677 
  def write(self, oprot):
9678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9680 
      return
3064 chandransh 9681 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9682 
    if self.success is not None:
3064 chandransh 9683 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9684 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9685 
      for iter132 in self.success:
9686 
        iter132.write(oprot)
3064 chandransh 9687 
      oprot.writeListEnd()
1528 ankur.sing 9688 
      oprot.writeFieldEnd()
9689 
    oprot.writeFieldStop()
9690 
    oprot.writeStructEnd()
9691 
 
3431 rajveer 9692 
  def validate(self):
9693 
    return
9694 
 
9695 
 
1528 ankur.sing 9696 
  def __repr__(self):
9697 
    L = ['%s=%r' % (key, value)
9698 
      for key, value in self.__dict__.iteritems()]
9699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9700 
 
9701 
  def __eq__(self, other):
9702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9703 
 
9704 
  def __ne__(self, other):
9705 
    return not (self == other)
9706 
 
1220 chandransh 9707 
class batchOrders_args:
9708 
  """
9709 
  Attributes:
9710 
   - warehouseId
9711 
  """
9712 
 
9713 
  thrift_spec = (
9714 
    None, # 0
9715 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9716 
  )
9717 
 
9718 
  def __init__(self, warehouseId=None,):
9719 
    self.warehouseId = warehouseId
9720 
 
9721 
  def read(self, iprot):
9722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9724 
      return
9725 
    iprot.readStructBegin()
9726 
    while True:
9727 
      (fname, ftype, fid) = iprot.readFieldBegin()
9728 
      if ftype == TType.STOP:
9729 
        break
9730 
      if fid == 1:
9731 
        if ftype == TType.I64:
9732 
          self.warehouseId = iprot.readI64();
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      else:
9736 
        iprot.skip(ftype)
9737 
      iprot.readFieldEnd()
9738 
    iprot.readStructEnd()
9739 
 
9740 
  def write(self, oprot):
9741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9743 
      return
9744 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9745 
    if self.warehouseId is not None:
1220 chandransh 9746 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9747 
      oprot.writeI64(self.warehouseId)
9748 
      oprot.writeFieldEnd()
9749 
    oprot.writeFieldStop()
9750 
    oprot.writeStructEnd()
9751 
 
3431 rajveer 9752 
  def validate(self):
9753 
    return
9754 
 
9755 
 
1220 chandransh 9756 
  def __repr__(self):
9757 
    L = ['%s=%r' % (key, value)
9758 
      for key, value in self.__dict__.iteritems()]
9759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9760 
 
9761 
  def __eq__(self, other):
9762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9763 
 
9764 
  def __ne__(self, other):
9765 
    return not (self == other)
9766 
 
9767 
class batchOrders_result:
9768 
  """
9769 
  Attributes:
9770 
   - success
9771 
   - ex
9772 
  """
9773 
 
9774 
  thrift_spec = (
9775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9777 
  )
9778 
 
9779 
  def __init__(self, success=None, ex=None,):
9780 
    self.success = success
9781 
    self.ex = ex
9782 
 
9783 
  def read(self, iprot):
9784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9786 
      return
9787 
    iprot.readStructBegin()
9788 
    while True:
9789 
      (fname, ftype, fid) = iprot.readFieldBegin()
9790 
      if ftype == TType.STOP:
9791 
        break
9792 
      if fid == 0:
9793 
        if ftype == TType.LIST:
9794 
          self.success = []
4133 chandransh 9795 
          (_etype136, _size133) = iprot.readListBegin()
9796 
          for _i137 in xrange(_size133):
9797 
            _elem138 = Order()
9798 
            _elem138.read(iprot)
9799 
            self.success.append(_elem138)
1220 chandransh 9800 
          iprot.readListEnd()
9801 
        else:
9802 
          iprot.skip(ftype)
9803 
      elif fid == 1:
9804 
        if ftype == TType.STRUCT:
9805 
          self.ex = TransactionServiceException()
9806 
          self.ex.read(iprot)
9807 
        else:
9808 
          iprot.skip(ftype)
9809 
      else:
9810 
        iprot.skip(ftype)
9811 
      iprot.readFieldEnd()
9812 
    iprot.readStructEnd()
9813 
 
9814 
  def write(self, oprot):
9815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9817 
      return
9818 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9819 
    if self.success is not None:
1220 chandransh 9820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9822 
      for iter139 in self.success:
9823 
        iter139.write(oprot)
1220 chandransh 9824 
      oprot.writeListEnd()
9825 
      oprot.writeFieldEnd()
3431 rajveer 9826 
    if self.ex is not None:
1220 chandransh 9827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9828 
      self.ex.write(oprot)
9829 
      oprot.writeFieldEnd()
9830 
    oprot.writeFieldStop()
9831 
    oprot.writeStructEnd()
9832 
 
3431 rajveer 9833 
  def validate(self):
9834 
    return
9835 
 
9836 
 
1220 chandransh 9837 
  def __repr__(self):
9838 
    L = ['%s=%r' % (key, value)
9839 
      for key, value in self.__dict__.iteritems()]
9840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9841 
 
9842 
  def __eq__(self, other):
9843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9844 
 
9845 
  def __ne__(self, other):
9846 
    return not (self == other)
9847 
 
1208 chandransh 9848 
class markOrderAsOutOfStock_args:
9849 
  """
9850 
  Attributes:
9851 
   - orderId
9852 
  """
9853 
 
9854 
  thrift_spec = (
9855 
    None, # 0
9856 
    (1, TType.I64, 'orderId', None, None, ), # 1
9857 
  )
9858 
 
9859 
  def __init__(self, orderId=None,):
9860 
    self.orderId = orderId
9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      if fid == 1:
9872 
        if ftype == TType.I64:
9873 
          self.orderId = iprot.readI64();
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      else:
9877 
        iprot.skip(ftype)
9878 
      iprot.readFieldEnd()
9879 
    iprot.readStructEnd()
9880 
 
9881 
  def write(self, oprot):
9882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9884 
      return
9885 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9886 
    if self.orderId is not None:
1208 chandransh 9887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9888 
      oprot.writeI64(self.orderId)
9889 
      oprot.writeFieldEnd()
9890 
    oprot.writeFieldStop()
9891 
    oprot.writeStructEnd()
9892 
 
3431 rajveer 9893 
  def validate(self):
9894 
    return
9895 
 
9896 
 
1208 chandransh 9897 
  def __repr__(self):
9898 
    L = ['%s=%r' % (key, value)
9899 
      for key, value in self.__dict__.iteritems()]
9900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9901 
 
9902 
  def __eq__(self, other):
9903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9904 
 
9905 
  def __ne__(self, other):
9906 
    return not (self == other)
9907 
 
9908 
class markOrderAsOutOfStock_result:
9909 
  """
9910 
  Attributes:
9911 
   - success
9912 
   - ex
9913 
  """
9914 
 
9915 
  thrift_spec = (
9916 
    (0, TType.BOOL, 'success', None, None, ), # 0
9917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9918 
  )
9919 
 
9920 
  def __init__(self, success=None, ex=None,):
9921 
    self.success = success
9922 
    self.ex = ex
9923 
 
9924 
  def read(self, iprot):
9925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9927 
      return
9928 
    iprot.readStructBegin()
9929 
    while True:
9930 
      (fname, ftype, fid) = iprot.readFieldBegin()
9931 
      if ftype == TType.STOP:
9932 
        break
9933 
      if fid == 0:
9934 
        if ftype == TType.BOOL:
9935 
          self.success = iprot.readBool();
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      elif fid == 1:
9939 
        if ftype == TType.STRUCT:
9940 
          self.ex = TransactionServiceException()
9941 
          self.ex.read(iprot)
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
9953 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9954 
    if self.success is not None:
1208 chandransh 9955 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9956 
      oprot.writeBool(self.success)
9957 
      oprot.writeFieldEnd()
3431 rajveer 9958 
    if self.ex is not None:
1208 chandransh 9959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9960 
      self.ex.write(oprot)
9961 
      oprot.writeFieldEnd()
9962 
    oprot.writeFieldStop()
9963 
    oprot.writeStructEnd()
9964 
 
3431 rajveer 9965 
  def validate(self):
9966 
    return
9967 
 
9968 
 
1208 chandransh 9969 
  def __repr__(self):
9970 
    L = ['%s=%r' % (key, value)
9971 
      for key, value in self.__dict__.iteritems()]
9972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9973 
 
9974 
  def __eq__(self, other):
9975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9976 
 
9977 
  def __ne__(self, other):
9978 
    return not (self == other)
9979 
 
3064 chandransh 9980 
class verifyOrder_args:
759 chandransh 9981 
  """
9982 
  Attributes:
3064 chandransh 9983 
   - orderId
759 chandransh 9984 
  """
9985 
 
9986 
  thrift_spec = (
9987 
    None, # 0
3064 chandransh 9988 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9989 
  )
9990 
 
3064 chandransh 9991 
  def __init__(self, orderId=None,):
9992 
    self.orderId = orderId
759 chandransh 9993 
 
9994 
  def read(self, iprot):
9995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9997 
      return
9998 
    iprot.readStructBegin()
9999 
    while True:
10000 
      (fname, ftype, fid) = iprot.readFieldBegin()
10001 
      if ftype == TType.STOP:
10002 
        break
10003 
      if fid == 1:
10004 
        if ftype == TType.I64:
3064 chandransh 10005 
          self.orderId = iprot.readI64();
759 chandransh 10006 
        else:
10007 
          iprot.skip(ftype)
10008 
      else:
10009 
        iprot.skip(ftype)
10010 
      iprot.readFieldEnd()
10011 
    iprot.readStructEnd()
10012 
 
10013 
  def write(self, oprot):
10014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10016 
      return
3064 chandransh 10017 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10018 
    if self.orderId is not None:
3064 chandransh 10019 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10020 
      oprot.writeI64(self.orderId)
759 chandransh 10021 
      oprot.writeFieldEnd()
10022 
    oprot.writeFieldStop()
10023 
    oprot.writeStructEnd()
10024 
 
3431 rajveer 10025 
  def validate(self):
10026 
    return
10027 
 
10028 
 
759 chandransh 10029 
  def __repr__(self):
10030 
    L = ['%s=%r' % (key, value)
10031 
      for key, value in self.__dict__.iteritems()]
10032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10033 
 
10034 
  def __eq__(self, other):
10035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10036 
 
10037 
  def __ne__(self, other):
10038 
    return not (self == other)
10039 
 
3064 chandransh 10040 
class verifyOrder_result:
759 chandransh 10041 
  """
10042 
  Attributes:
10043 
   - success
10044 
   - ex
10045 
  """
10046 
 
10047 
  thrift_spec = (
10048 
    (0, TType.BOOL, 'success', None, None, ), # 0
10049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10050 
  )
10051 
 
10052 
  def __init__(self, success=None, ex=None,):
10053 
    self.success = success
10054 
    self.ex = ex
10055 
 
10056 
  def read(self, iprot):
10057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10059 
      return
10060 
    iprot.readStructBegin()
10061 
    while True:
10062 
      (fname, ftype, fid) = iprot.readFieldBegin()
10063 
      if ftype == TType.STOP:
10064 
        break
10065 
      if fid == 0:
10066 
        if ftype == TType.BOOL:
10067 
          self.success = iprot.readBool();
10068 
        else:
10069 
          iprot.skip(ftype)
10070 
      elif fid == 1:
10071 
        if ftype == TType.STRUCT:
10072 
          self.ex = TransactionServiceException()
10073 
          self.ex.read(iprot)
10074 
        else:
10075 
          iprot.skip(ftype)
10076 
      else:
10077 
        iprot.skip(ftype)
10078 
      iprot.readFieldEnd()
10079 
    iprot.readStructEnd()
10080 
 
10081 
  def write(self, oprot):
10082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10084 
      return
3064 chandransh 10085 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10086 
    if self.success is not None:
759 chandransh 10087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10088 
      oprot.writeBool(self.success)
10089 
      oprot.writeFieldEnd()
3431 rajveer 10090 
    if self.ex is not None:
759 chandransh 10091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10092 
      self.ex.write(oprot)
10093 
      oprot.writeFieldEnd()
10094 
    oprot.writeFieldStop()
10095 
    oprot.writeStructEnd()
10096 
 
3431 rajveer 10097 
  def validate(self):
10098 
    return
10099 
 
10100 
 
759 chandransh 10101 
  def __repr__(self):
10102 
    L = ['%s=%r' % (key, value)
10103 
      for key, value in self.__dict__.iteritems()]
10104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10105 
 
10106 
  def __eq__(self, other):
10107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10108 
 
10109 
  def __ne__(self, other):
10110 
    return not (self == other)
10111 
 
3064 chandransh 10112 
class acceptOrder_args:
1113 chandransh 10113 
  """
10114 
  Attributes:
3064 chandransh 10115 
   - orderId
1113 chandransh 10116 
  """
10117 
 
10118 
  thrift_spec = (
10119 
    None, # 0
3064 chandransh 10120 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10121 
  )
10122 
 
3064 chandransh 10123 
  def __init__(self, orderId=None,):
10124 
    self.orderId = orderId
1113 chandransh 10125 
 
10126 
  def read(self, iprot):
10127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10129 
      return
10130 
    iprot.readStructBegin()
10131 
    while True:
10132 
      (fname, ftype, fid) = iprot.readFieldBegin()
10133 
      if ftype == TType.STOP:
10134 
        break
10135 
      if fid == 1:
10136 
        if ftype == TType.I64:
3064 chandransh 10137 
          self.orderId = iprot.readI64();
1113 chandransh 10138 
        else:
10139 
          iprot.skip(ftype)
10140 
      else:
10141 
        iprot.skip(ftype)
10142 
      iprot.readFieldEnd()
10143 
    iprot.readStructEnd()
10144 
 
10145 
  def write(self, oprot):
10146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10148 
      return
3064 chandransh 10149 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10150 
    if self.orderId is not None:
3064 chandransh 10151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10152 
      oprot.writeI64(self.orderId)
1113 chandransh 10153 
      oprot.writeFieldEnd()
10154 
    oprot.writeFieldStop()
10155 
    oprot.writeStructEnd()
10156 
 
3431 rajveer 10157 
  def validate(self):
10158 
    return
10159 
 
10160 
 
1113 chandransh 10161 
  def __repr__(self):
10162 
    L = ['%s=%r' % (key, value)
10163 
      for key, value in self.__dict__.iteritems()]
10164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10165 
 
10166 
  def __eq__(self, other):
10167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10168 
 
10169 
  def __ne__(self, other):
10170 
    return not (self == other)
10171 
 
3064 chandransh 10172 
class acceptOrder_result:
1113 chandransh 10173 
  """
10174 
  Attributes:
10175 
   - success
10176 
   - ex
10177 
  """
10178 
 
10179 
  thrift_spec = (
3064 chandransh 10180 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10182 
  )
10183 
 
10184 
  def __init__(self, success=None, ex=None,):
10185 
    self.success = success
10186 
    self.ex = ex
10187 
 
10188 
  def read(self, iprot):
10189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10191 
      return
10192 
    iprot.readStructBegin()
10193 
    while True:
10194 
      (fname, ftype, fid) = iprot.readFieldBegin()
10195 
      if ftype == TType.STOP:
10196 
        break
10197 
      if fid == 0:
3064 chandransh 10198 
        if ftype == TType.BOOL:
10199 
          self.success = iprot.readBool();
1113 chandransh 10200 
        else:
10201 
          iprot.skip(ftype)
10202 
      elif fid == 1:
10203 
        if ftype == TType.STRUCT:
10204 
          self.ex = TransactionServiceException()
10205 
          self.ex.read(iprot)
10206 
        else:
10207 
          iprot.skip(ftype)
10208 
      else:
10209 
        iprot.skip(ftype)
10210 
      iprot.readFieldEnd()
10211 
    iprot.readStructEnd()
10212 
 
10213 
  def write(self, oprot):
10214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10216 
      return
3064 chandransh 10217 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10218 
    if self.success is not None:
3064 chandransh 10219 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10220 
      oprot.writeBool(self.success)
1113 chandransh 10221 
      oprot.writeFieldEnd()
3431 rajveer 10222 
    if self.ex is not None:
1113 chandransh 10223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10224 
      self.ex.write(oprot)
10225 
      oprot.writeFieldEnd()
10226 
    oprot.writeFieldStop()
10227 
    oprot.writeStructEnd()
10228 
 
3431 rajveer 10229 
  def validate(self):
10230 
    return
10231 
 
10232 
 
1113 chandransh 10233 
  def __repr__(self):
10234 
    L = ['%s=%r' % (key, value)
10235 
      for key, value in self.__dict__.iteritems()]
10236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10237 
 
10238 
  def __eq__(self, other):
10239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10240 
 
10241 
  def __ne__(self, other):
10242 
    return not (self == other)
10243 
 
3064 chandransh 10244 
class addBillingDetails_args:
1135 chandransh 10245 
  """
10246 
  Attributes:
3064 chandransh 10247 
   - orderId
10248 
   - invoice_number
4658 mandeep.dh 10249 
   - serialNumber
4283 anupam.sin 10250 
   - itemNumber
3064 chandransh 10251 
   - billed_by
4264 rajveer 10252 
   - jacketNumber
4283 anupam.sin 10253 
   - billingType
10254 
   - vendorId
1135 chandransh 10255 
  """
10256 
 
10257 
  thrift_spec = (
10258 
    None, # 0
3064 chandransh 10259 
    (1, TType.I64, 'orderId', None, None, ), # 1
10260 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10261 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10262 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10263 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10264 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10265 
    (7, TType.I64, 'billingType', None, None, ), # 7
10266 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10267 
  )
10268 
 
4658 mandeep.dh 10269 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10270 
    self.orderId = orderId
10271 
    self.invoice_number = invoice_number
4658 mandeep.dh 10272 
    self.serialNumber = serialNumber
4283 anupam.sin 10273 
    self.itemNumber = itemNumber
3064 chandransh 10274 
    self.billed_by = billed_by
4264 rajveer 10275 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10276 
    self.billingType = billingType
10277 
    self.vendorId = vendorId
1135 chandransh 10278 
 
10279 
  def read(self, iprot):
10280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10282 
      return
10283 
    iprot.readStructBegin()
10284 
    while True:
10285 
      (fname, ftype, fid) = iprot.readFieldBegin()
10286 
      if ftype == TType.STOP:
10287 
        break
10288 
      if fid == 1:
10289 
        if ftype == TType.I64:
3064 chandransh 10290 
          self.orderId = iprot.readI64();
1135 chandransh 10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      elif fid == 2:
3064 chandransh 10294 
        if ftype == TType.STRING:
10295 
          self.invoice_number = iprot.readString();
1135 chandransh 10296 
        else:
10297 
          iprot.skip(ftype)
3064 chandransh 10298 
      elif fid == 3:
4658 mandeep.dh 10299 
        if ftype == TType.STRING:
10300 
          self.serialNumber = iprot.readString();
3064 chandransh 10301 
        else:
10302 
          iprot.skip(ftype)
10303 
      elif fid == 4:
10304 
        if ftype == TType.STRING:
10305 
          self.itemNumber = iprot.readString();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      elif fid == 5:
10309 
        if ftype == TType.STRING:
4283 anupam.sin 10310 
          self.billed_by = iprot.readString();
3064 chandransh 10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      elif fid == 6:
10314 
        if ftype == TType.I64:
4283 anupam.sin 10315 
          self.jacketNumber = iprot.readI64();
10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      elif fid == 7:
10319 
        if ftype == TType.I64:
3064 chandransh 10320 
          self.billingType = iprot.readI64();
10321 
        else:
10322 
          iprot.skip(ftype)
4283 anupam.sin 10323 
      elif fid == 8:
10324 
        if ftype == TType.I64:
10325 
          self.vendorId = iprot.readI64();
10326 
        else:
10327 
          iprot.skip(ftype)
1246 chandransh 10328 
      else:
10329 
        iprot.skip(ftype)
10330 
      iprot.readFieldEnd()
10331 
    iprot.readStructEnd()
10332 
 
10333 
  def write(self, oprot):
10334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10336 
      return
4283 anupam.sin 10337 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10338 
    if self.orderId is not None:
3064 chandransh 10339 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10340 
      oprot.writeI64(self.orderId)
1246 chandransh 10341 
      oprot.writeFieldEnd()
4283 anupam.sin 10342 
    if self.invoice_number is not None:
10343 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10344 
      oprot.writeString(self.invoice_number)
1246 chandransh 10345 
      oprot.writeFieldEnd()
4658 mandeep.dh 10346 
    if self.serialNumber is not None:
10347 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10348 
      oprot.writeString(self.serialNumber)
3064 chandransh 10349 
      oprot.writeFieldEnd()
3431 rajveer 10350 
    if self.itemNumber is not None:
3064 chandransh 10351 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10352 
      oprot.writeString(self.itemNumber)
10353 
      oprot.writeFieldEnd()
4283 anupam.sin 10354 
    if self.billed_by is not None:
10355 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10356 
      oprot.writeString(self.billed_by)
3064 chandransh 10357 
      oprot.writeFieldEnd()
4283 anupam.sin 10358 
    if self.jacketNumber is not None:
10359 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10360 
      oprot.writeI64(self.jacketNumber)
10361 
      oprot.writeFieldEnd()
3431 rajveer 10362 
    if self.billingType is not None:
4283 anupam.sin 10363 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10364 
      oprot.writeI64(self.billingType)
10365 
      oprot.writeFieldEnd()
4283 anupam.sin 10366 
    if self.vendorId is not None:
10367 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10368 
      oprot.writeI64(self.vendorId)
10369 
      oprot.writeFieldEnd()
1246 chandransh 10370 
    oprot.writeFieldStop()
10371 
    oprot.writeStructEnd()
10372 
 
3431 rajveer 10373 
  def validate(self):
10374 
    return
10375 
 
10376 
 
1246 chandransh 10377 
  def __repr__(self):
10378 
    L = ['%s=%r' % (key, value)
10379 
      for key, value in self.__dict__.iteritems()]
10380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10381 
 
10382 
  def __eq__(self, other):
10383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10384 
 
10385 
  def __ne__(self, other):
10386 
    return not (self == other)
10387 
 
4283 anupam.sin 10388 
class addBillingDetails_result:
1246 chandransh 10389 
  """
10390 
  Attributes:
3064 chandransh 10391 
   - success
1246 chandransh 10392 
   - ex
10393 
  """
10394 
 
10395 
  thrift_spec = (
3064 chandransh 10396 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10397 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10398 
  )
10399 
 
3064 chandransh 10400 
  def __init__(self, success=None, ex=None,):
10401 
    self.success = success
1246 chandransh 10402 
    self.ex = ex
10403 
 
10404 
  def read(self, iprot):
10405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10407 
      return
10408 
    iprot.readStructBegin()
10409 
    while True:
10410 
      (fname, ftype, fid) = iprot.readFieldBegin()
10411 
      if ftype == TType.STOP:
10412 
        break
3064 chandransh 10413 
      if fid == 0:
10414 
        if ftype == TType.BOOL:
10415 
          self.success = iprot.readBool();
10416 
        else:
10417 
          iprot.skip(ftype)
10418 
      elif fid == 1:
1246 chandransh 10419 
        if ftype == TType.STRUCT:
10420 
          self.ex = TransactionServiceException()
10421 
          self.ex.read(iprot)
10422 
        else:
10423 
          iprot.skip(ftype)
10424 
      else:
10425 
        iprot.skip(ftype)
10426 
      iprot.readFieldEnd()
10427 
    iprot.readStructEnd()
10428 
 
10429 
  def write(self, oprot):
10430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10432 
      return
4283 anupam.sin 10433 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10434 
    if self.success is not None:
3064 chandransh 10435 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10436 
      oprot.writeBool(self.success)
10437 
      oprot.writeFieldEnd()
3431 rajveer 10438 
    if self.ex is not None:
1246 chandransh 10439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10440 
      self.ex.write(oprot)
10441 
      oprot.writeFieldEnd()
10442 
    oprot.writeFieldStop()
10443 
    oprot.writeStructEnd()
10444 
 
3431 rajveer 10445 
  def validate(self):
10446 
    return
10447 
 
10448 
 
1246 chandransh 10449 
  def __repr__(self):
10450 
    L = ['%s=%r' % (key, value)
10451 
      for key, value in self.__dict__.iteritems()]
10452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10453 
 
10454 
  def __eq__(self, other):
10455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10456 
 
10457 
  def __ne__(self, other):
10458 
    return not (self == other)
10459 
 
4579 rajveer 10460 
class addInvoiceNumber_args:
10461 
  """
10462 
  Attributes:
10463 
   - orderId
10464 
   - invoiceNumber
10465 
  """
10466 
 
10467 
  thrift_spec = (
10468 
    None, # 0
10469 
    (1, TType.I64, 'orderId', None, None, ), # 1
10470 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10471 
  )
10472 
 
10473 
  def __init__(self, orderId=None, invoiceNumber=None,):
10474 
    self.orderId = orderId
10475 
    self.invoiceNumber = invoiceNumber
10476 
 
10477 
  def read(self, iprot):
10478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10480 
      return
10481 
    iprot.readStructBegin()
10482 
    while True:
10483 
      (fname, ftype, fid) = iprot.readFieldBegin()
10484 
      if ftype == TType.STOP:
10485 
        break
10486 
      if fid == 1:
10487 
        if ftype == TType.I64:
10488 
          self.orderId = iprot.readI64();
10489 
        else:
10490 
          iprot.skip(ftype)
10491 
      elif fid == 2:
10492 
        if ftype == TType.STRING:
10493 
          self.invoiceNumber = iprot.readString();
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      else:
10497 
        iprot.skip(ftype)
10498 
      iprot.readFieldEnd()
10499 
    iprot.readStructEnd()
10500 
 
10501 
  def write(self, oprot):
10502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10504 
      return
10505 
    oprot.writeStructBegin('addInvoiceNumber_args')
10506 
    if self.orderId is not None:
10507 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10508 
      oprot.writeI64(self.orderId)
10509 
      oprot.writeFieldEnd()
10510 
    if self.invoiceNumber is not None:
10511 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10512 
      oprot.writeString(self.invoiceNumber)
10513 
      oprot.writeFieldEnd()
10514 
    oprot.writeFieldStop()
10515 
    oprot.writeStructEnd()
10516 
 
10517 
  def validate(self):
10518 
    return
10519 
 
10520 
 
10521 
  def __repr__(self):
10522 
    L = ['%s=%r' % (key, value)
10523 
      for key, value in self.__dict__.iteritems()]
10524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10525 
 
10526 
  def __eq__(self, other):
10527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10528 
 
10529 
  def __ne__(self, other):
10530 
    return not (self == other)
10531 
 
10532 
class addInvoiceNumber_result:
10533 
  """
10534 
  Attributes:
10535 
   - ex
10536 
  """
10537 
 
10538 
  thrift_spec = (
10539 
    None, # 0
10540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10541 
  )
10542 
 
10543 
  def __init__(self, ex=None,):
10544 
    self.ex = ex
10545 
 
10546 
  def read(self, iprot):
10547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10549 
      return
10550 
    iprot.readStructBegin()
10551 
    while True:
10552 
      (fname, ftype, fid) = iprot.readFieldBegin()
10553 
      if ftype == TType.STOP:
10554 
        break
10555 
      if fid == 1:
10556 
        if ftype == TType.STRUCT:
10557 
          self.ex = TransactionServiceException()
10558 
          self.ex.read(iprot)
10559 
        else:
10560 
          iprot.skip(ftype)
10561 
      else:
10562 
        iprot.skip(ftype)
10563 
      iprot.readFieldEnd()
10564 
    iprot.readStructEnd()
10565 
 
10566 
  def write(self, oprot):
10567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10569 
      return
10570 
    oprot.writeStructBegin('addInvoiceNumber_result')
10571 
    if self.ex is not None:
10572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10573 
      self.ex.write(oprot)
10574 
      oprot.writeFieldEnd()
10575 
    oprot.writeFieldStop()
10576 
    oprot.writeStructEnd()
10577 
 
10578 
  def validate(self):
10579 
    return
10580 
 
10581 
 
10582 
  def __repr__(self):
10583 
    L = ['%s=%r' % (key, value)
10584 
      for key, value in self.__dict__.iteritems()]
10585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10586 
 
10587 
  def __eq__(self, other):
10588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10589 
 
10590 
  def __ne__(self, other):
10591 
    return not (self == other)
10592 
 
3064 chandransh 10593 
class markOrdersAsManifested_args:
1408 ankur.sing 10594 
  """
10595 
  Attributes:
3064 chandransh 10596 
   - warehouseId
1408 ankur.sing 10597 
   - providerId
3064 chandransh 10598 
   - cod
1408 ankur.sing 10599 
  """
10600 
 
10601 
  thrift_spec = (
10602 
    None, # 0
3064 chandransh 10603 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10604 
    (2, TType.I64, 'providerId', None, None, ), # 2
10605 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10606 
  )
10607 
 
3064 chandransh 10608 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10609 
    self.warehouseId = warehouseId
1408 ankur.sing 10610 
    self.providerId = providerId
3064 chandransh 10611 
    self.cod = cod
1408 ankur.sing 10612 
 
10613 
  def read(self, iprot):
10614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10616 
      return
10617 
    iprot.readStructBegin()
10618 
    while True:
10619 
      (fname, ftype, fid) = iprot.readFieldBegin()
10620 
      if ftype == TType.STOP:
10621 
        break
10622 
      if fid == 1:
10623 
        if ftype == TType.I64:
3064 chandransh 10624 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10625 
        else:
10626 
          iprot.skip(ftype)
10627 
      elif fid == 2:
10628 
        if ftype == TType.I64:
3064 chandransh 10629 
          self.providerId = iprot.readI64();
1408 ankur.sing 10630 
        else:
10631 
          iprot.skip(ftype)
3064 chandransh 10632 
      elif fid == 3:
10633 
        if ftype == TType.BOOL:
10634 
          self.cod = iprot.readBool();
10635 
        else:
10636 
          iprot.skip(ftype)
1408 ankur.sing 10637 
      else:
10638 
        iprot.skip(ftype)
10639 
      iprot.readFieldEnd()
10640 
    iprot.readStructEnd()
10641 
 
10642 
  def write(self, oprot):
10643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10645 
      return
3064 chandransh 10646 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10647 
    if self.warehouseId is not None:
3064 chandransh 10648 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10649 
      oprot.writeI64(self.warehouseId)
10650 
      oprot.writeFieldEnd()
3431 rajveer 10651 
    if self.providerId is not None:
3064 chandransh 10652 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10653 
      oprot.writeI64(self.providerId)
10654 
      oprot.writeFieldEnd()
3431 rajveer 10655 
    if self.cod is not None:
3064 chandransh 10656 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10657 
      oprot.writeBool(self.cod)
1408 ankur.sing 10658 
      oprot.writeFieldEnd()
10659 
    oprot.writeFieldStop()
10660 
    oprot.writeStructEnd()
10661 
 
3431 rajveer 10662 
  def validate(self):
10663 
    return
10664 
 
10665 
 
1408 ankur.sing 10666 
  def __repr__(self):
10667 
    L = ['%s=%r' % (key, value)
10668 
      for key, value in self.__dict__.iteritems()]
10669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10670 
 
10671 
  def __eq__(self, other):
10672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10673 
 
10674 
  def __ne__(self, other):
10675 
    return not (self == other)
10676 
 
3064 chandransh 10677 
class markOrdersAsManifested_result:
1408 ankur.sing 10678 
  """
10679 
  Attributes:
10680 
   - success
3064 chandransh 10681 
   - ex
1408 ankur.sing 10682 
  """
10683 
 
10684 
  thrift_spec = (
3064 chandransh 10685 
    (0, TType.BOOL, 'success', None, None, ), # 0
10686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10687 
  )
10688 
 
3064 chandransh 10689 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10690 
    self.success = success
3064 chandransh 10691 
    self.ex = ex
1408 ankur.sing 10692 
 
10693 
  def read(self, iprot):
10694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10696 
      return
10697 
    iprot.readStructBegin()
10698 
    while True:
10699 
      (fname, ftype, fid) = iprot.readFieldBegin()
10700 
      if ftype == TType.STOP:
10701 
        break
10702 
      if fid == 0:
3064 chandransh 10703 
        if ftype == TType.BOOL:
10704 
          self.success = iprot.readBool();
1408 ankur.sing 10705 
        else:
10706 
          iprot.skip(ftype)
3064 chandransh 10707 
      elif fid == 1:
10708 
        if ftype == TType.STRUCT:
10709 
          self.ex = TransactionServiceException()
10710 
          self.ex.read(iprot)
10711 
        else:
10712 
          iprot.skip(ftype)
1408 ankur.sing 10713 
      else:
10714 
        iprot.skip(ftype)
10715 
      iprot.readFieldEnd()
10716 
    iprot.readStructEnd()
10717 
 
10718 
  def write(self, oprot):
10719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10721 
      return
3064 chandransh 10722 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10723 
    if self.success is not None:
3064 chandransh 10724 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10725 
      oprot.writeBool(self.success)
1408 ankur.sing 10726 
      oprot.writeFieldEnd()
3431 rajveer 10727 
    if self.ex is not None:
3064 chandransh 10728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10729 
      self.ex.write(oprot)
10730 
      oprot.writeFieldEnd()
1408 ankur.sing 10731 
    oprot.writeFieldStop()
10732 
    oprot.writeStructEnd()
10733 
 
3431 rajveer 10734 
  def validate(self):
10735 
    return
10736 
 
10737 
 
1408 ankur.sing 10738 
  def __repr__(self):
10739 
    L = ['%s=%r' % (key, value)
10740 
      for key, value in self.__dict__.iteritems()]
10741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10742 
 
10743 
  def __eq__(self, other):
10744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10745 
 
10746 
  def __ne__(self, other):
10747 
    return not (self == other)
10748 
 
4410 rajveer 10749 
class markOrdersAsShippedFromWarehouse_args:
10750 
  """
10751 
  Attributes:
10752 
   - warehouseId
10753 
   - providerId
10754 
   - cod
10755 
  """
10756 
 
10757 
  thrift_spec = (
10758 
    None, # 0
10759 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10760 
    (2, TType.I64, 'providerId', None, None, ), # 2
10761 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10762 
  )
10763 
 
10764 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10765 
    self.warehouseId = warehouseId
10766 
    self.providerId = providerId
10767 
    self.cod = cod
10768 
 
10769 
  def read(self, iprot):
10770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10772 
      return
10773 
    iprot.readStructBegin()
10774 
    while True:
10775 
      (fname, ftype, fid) = iprot.readFieldBegin()
10776 
      if ftype == TType.STOP:
10777 
        break
10778 
      if fid == 1:
10779 
        if ftype == TType.I64:
10780 
          self.warehouseId = iprot.readI64();
10781 
        else:
10782 
          iprot.skip(ftype)
10783 
      elif fid == 2:
10784 
        if ftype == TType.I64:
10785 
          self.providerId = iprot.readI64();
10786 
        else:
10787 
          iprot.skip(ftype)
10788 
      elif fid == 3:
10789 
        if ftype == TType.BOOL:
10790 
          self.cod = iprot.readBool();
10791 
        else:
10792 
          iprot.skip(ftype)
10793 
      else:
10794 
        iprot.skip(ftype)
10795 
      iprot.readFieldEnd()
10796 
    iprot.readStructEnd()
10797 
 
10798 
  def write(self, oprot):
10799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10801 
      return
10802 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10803 
    if self.warehouseId is not None:
10804 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10805 
      oprot.writeI64(self.warehouseId)
10806 
      oprot.writeFieldEnd()
10807 
    if self.providerId is not None:
10808 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10809 
      oprot.writeI64(self.providerId)
10810 
      oprot.writeFieldEnd()
10811 
    if self.cod is not None:
10812 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10813 
      oprot.writeBool(self.cod)
10814 
      oprot.writeFieldEnd()
10815 
    oprot.writeFieldStop()
10816 
    oprot.writeStructEnd()
10817 
 
10818 
  def validate(self):
10819 
    return
10820 
 
10821 
 
10822 
  def __repr__(self):
10823 
    L = ['%s=%r' % (key, value)
10824 
      for key, value in self.__dict__.iteritems()]
10825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10826 
 
10827 
  def __eq__(self, other):
10828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10829 
 
10830 
  def __ne__(self, other):
10831 
    return not (self == other)
10832 
 
10833 
class markOrdersAsShippedFromWarehouse_result:
10834 
  """
10835 
  Attributes:
10836 
   - success
10837 
   - ex
10838 
  """
10839 
 
10840 
  thrift_spec = (
10841 
    (0, TType.BOOL, 'success', None, None, ), # 0
10842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10843 
  )
10844 
 
10845 
  def __init__(self, success=None, ex=None,):
10846 
    self.success = success
10847 
    self.ex = ex
10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      if fid == 0:
10859 
        if ftype == TType.BOOL:
10860 
          self.success = iprot.readBool();
10861 
        else:
10862 
          iprot.skip(ftype)
10863 
      elif fid == 1:
10864 
        if ftype == TType.STRUCT:
10865 
          self.ex = TransactionServiceException()
10866 
          self.ex.read(iprot)
10867 
        else:
10868 
          iprot.skip(ftype)
10869 
      else:
10870 
        iprot.skip(ftype)
10871 
      iprot.readFieldEnd()
10872 
    iprot.readStructEnd()
10873 
 
10874 
  def write(self, oprot):
10875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10877 
      return
10878 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10879 
    if self.success is not None:
10880 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10881 
      oprot.writeBool(self.success)
10882 
      oprot.writeFieldEnd()
10883 
    if self.ex is not None:
10884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10885 
      self.ex.write(oprot)
10886 
      oprot.writeFieldEnd()
10887 
    oprot.writeFieldStop()
10888 
    oprot.writeStructEnd()
10889 
 
10890 
  def validate(self):
10891 
    return
10892 
 
10893 
 
10894 
  def __repr__(self):
10895 
    L = ['%s=%r' % (key, value)
10896 
      for key, value in self.__dict__.iteritems()]
10897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10898 
 
10899 
  def __eq__(self, other):
10900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10901 
 
10902 
  def __ne__(self, other):
10903 
    return not (self == other)
10904 
 
3064 chandransh 10905 
class markOrdersAsPickedUp_args:
304 ashish 10906 
  """
10907 
  Attributes:
3064 chandransh 10908 
   - providerId
10909 
   - pickupDetails
304 ashish 10910 
  """
94 ashish 10911 
 
304 ashish 10912 
  thrift_spec = (
10913 
    None, # 0
3064 chandransh 10914 
    (1, TType.I64, 'providerId', None, None, ), # 1
10915 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10916 
  )
10917 
 
3064 chandransh 10918 
  def __init__(self, providerId=None, pickupDetails=None,):
10919 
    self.providerId = providerId
10920 
    self.pickupDetails = pickupDetails
304 ashish 10921 
 
10922 
  def read(self, iprot):
10923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10925 
      return
10926 
    iprot.readStructBegin()
10927 
    while True:
10928 
      (fname, ftype, fid) = iprot.readFieldBegin()
10929 
      if ftype == TType.STOP:
10930 
        break
10931 
      if fid == 1:
10932 
        if ftype == TType.I64:
3064 chandransh 10933 
          self.providerId = iprot.readI64();
304 ashish 10934 
        else:
10935 
          iprot.skip(ftype)
10936 
      elif fid == 2:
3064 chandransh 10937 
        if ftype == TType.MAP:
10938 
          self.pickupDetails = {}
4133 chandransh 10939 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10940 
          for _i144 in xrange(_size140):
10941 
            _key145 = iprot.readString();
10942 
            _val146 = iprot.readString();
10943 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10944 
          iprot.readMapEnd()
304 ashish 10945 
        else:
10946 
          iprot.skip(ftype)
10947 
      else:
10948 
        iprot.skip(ftype)
10949 
      iprot.readFieldEnd()
10950 
    iprot.readStructEnd()
10951 
 
10952 
  def write(self, oprot):
10953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10955 
      return
3064 chandransh 10956 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10957 
    if self.providerId is not None:
3064 chandransh 10958 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10959 
      oprot.writeI64(self.providerId)
304 ashish 10960 
      oprot.writeFieldEnd()
3431 rajveer 10961 
    if self.pickupDetails is not None:
3064 chandransh 10962 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10963 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10964 
      for kiter147,viter148 in self.pickupDetails.items():
10965 
        oprot.writeString(kiter147)
10966 
        oprot.writeString(viter148)
3064 chandransh 10967 
      oprot.writeMapEnd()
304 ashish 10968 
      oprot.writeFieldEnd()
10969 
    oprot.writeFieldStop()
10970 
    oprot.writeStructEnd()
10971 
 
3431 rajveer 10972 
  def validate(self):
10973 
    return
10974 
 
10975 
 
304 ashish 10976 
  def __repr__(self):
10977 
    L = ['%s=%r' % (key, value)
10978 
      for key, value in self.__dict__.iteritems()]
10979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10980 
 
10981 
  def __eq__(self, other):
10982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10983 
 
10984 
  def __ne__(self, other):
10985 
    return not (self == other)
10986 
 
3064 chandransh 10987 
class markOrdersAsPickedUp_result:
304 ashish 10988 
  """
10989 
  Attributes:
10990 
   - success
3064 chandransh 10991 
   - ex
304 ashish 10992 
  """
10993 
 
10994 
  thrift_spec = (
3064 chandransh 10995 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10997 
  )
10998 
 
3064 chandransh 10999 
  def __init__(self, success=None, ex=None,):
304 ashish 11000 
    self.success = success
3064 chandransh 11001 
    self.ex = ex
304 ashish 11002 
 
11003 
  def read(self, iprot):
11004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11006 
      return
11007 
    iprot.readStructBegin()
11008 
    while True:
11009 
      (fname, ftype, fid) = iprot.readFieldBegin()
11010 
      if ftype == TType.STOP:
11011 
        break
11012 
      if fid == 0:
11013 
        if ftype == TType.LIST:
11014 
          self.success = []
4133 chandransh 11015 
          (_etype152, _size149) = iprot.readListBegin()
11016 
          for _i153 in xrange(_size149):
11017 
            _elem154 = Order()
11018 
            _elem154.read(iprot)
11019 
            self.success.append(_elem154)
304 ashish 11020 
          iprot.readListEnd()
11021 
        else:
11022 
          iprot.skip(ftype)
3064 chandransh 11023 
      elif fid == 1:
11024 
        if ftype == TType.STRUCT:
11025 
          self.ex = TransactionServiceException()
11026 
          self.ex.read(iprot)
11027 
        else:
11028 
          iprot.skip(ftype)
304 ashish 11029 
      else:
11030 
        iprot.skip(ftype)
11031 
      iprot.readFieldEnd()
11032 
    iprot.readStructEnd()
11033 
 
11034 
  def write(self, oprot):
11035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11037 
      return
3064 chandransh 11038 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11039 
    if self.success is not None:
304 ashish 11040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11041 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11042 
      for iter155 in self.success:
11043 
        iter155.write(oprot)
304 ashish 11044 
      oprot.writeListEnd()
11045 
      oprot.writeFieldEnd()
3431 rajveer 11046 
    if self.ex is not None:
3064 chandransh 11047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11048 
      self.ex.write(oprot)
11049 
      oprot.writeFieldEnd()
304 ashish 11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
3431 rajveer 11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
304 ashish 11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
3064 chandransh 11068 
class markOrdersAsDelivered_args:
304 ashish 11069 
  """
11070 
  Attributes:
3064 chandransh 11071 
   - providerId
11072 
   - deliveredOrders
304 ashish 11073 
  """
11074 
 
11075 
  thrift_spec = (
11076 
    None, # 0
3064 chandransh 11077 
    (1, TType.I64, 'providerId', None, None, ), # 1
11078 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11079 
  )
11080 
 
3064 chandransh 11081 
  def __init__(self, providerId=None, deliveredOrders=None,):
11082 
    self.providerId = providerId
11083 
    self.deliveredOrders = deliveredOrders
304 ashish 11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 1:
11095 
        if ftype == TType.I64:
3064 chandransh 11096 
          self.providerId = iprot.readI64();
304 ashish 11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      elif fid == 2:
3064 chandransh 11100 
        if ftype == TType.MAP:
11101 
          self.deliveredOrders = {}
4133 chandransh 11102 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11103 
          for _i160 in xrange(_size156):
11104 
            _key161 = iprot.readString();
11105 
            _val162 = iprot.readString();
11106 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11107 
          iprot.readMapEnd()
304 ashish 11108 
        else:
11109 
          iprot.skip(ftype)
11110 
      else:
11111 
        iprot.skip(ftype)
11112 
      iprot.readFieldEnd()
11113 
    iprot.readStructEnd()
11114 
 
11115 
  def write(self, oprot):
11116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11118 
      return
3064 chandransh 11119 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11120 
    if self.providerId is not None:
3064 chandransh 11121 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11122 
      oprot.writeI64(self.providerId)
304 ashish 11123 
      oprot.writeFieldEnd()
3431 rajveer 11124 
    if self.deliveredOrders is not None:
3064 chandransh 11125 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11126 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11127 
      for kiter163,viter164 in self.deliveredOrders.items():
11128 
        oprot.writeString(kiter163)
11129 
        oprot.writeString(viter164)
3064 chandransh 11130 
      oprot.writeMapEnd()
304 ashish 11131 
      oprot.writeFieldEnd()
11132 
    oprot.writeFieldStop()
11133 
    oprot.writeStructEnd()
11134 
 
3431 rajveer 11135 
  def validate(self):
11136 
    return
11137 
 
11138 
 
304 ashish 11139 
  def __repr__(self):
11140 
    L = ['%s=%r' % (key, value)
11141 
      for key, value in self.__dict__.iteritems()]
11142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11143 
 
11144 
  def __eq__(self, other):
11145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11146 
 
11147 
  def __ne__(self, other):
11148 
    return not (self == other)
11149 
 
3064 chandransh 11150 
class markOrdersAsDelivered_result:
11151 
  """
11152 
  Attributes:
11153 
   - ex
11154 
  """
304 ashish 11155 
 
11156 
  thrift_spec = (
3064 chandransh 11157 
    None, # 0
11158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11159 
  )
11160 
 
3064 chandransh 11161 
  def __init__(self, ex=None,):
11162 
    self.ex = ex
304 ashish 11163 
 
1596 ankur.sing 11164 
  def read(self, iprot):
11165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11167 
      return
11168 
    iprot.readStructBegin()
11169 
    while True:
11170 
      (fname, ftype, fid) = iprot.readFieldBegin()
11171 
      if ftype == TType.STOP:
11172 
        break
3064 chandransh 11173 
      if fid == 1:
11174 
        if ftype == TType.STRUCT:
11175 
          self.ex = TransactionServiceException()
11176 
          self.ex.read(iprot)
11177 
        else:
11178 
          iprot.skip(ftype)
1596 ankur.sing 11179 
      else:
11180 
        iprot.skip(ftype)
11181 
      iprot.readFieldEnd()
11182 
    iprot.readStructEnd()
11183 
 
11184 
  def write(self, oprot):
11185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11187 
      return
3064 chandransh 11188 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11189 
    if self.ex is not None:
3064 chandransh 11190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11191 
      self.ex.write(oprot)
11192 
      oprot.writeFieldEnd()
1596 ankur.sing 11193 
    oprot.writeFieldStop()
11194 
    oprot.writeStructEnd()
11195 
 
3431 rajveer 11196 
  def validate(self):
11197 
    return
11198 
 
11199 
 
1596 ankur.sing 11200 
  def __repr__(self):
11201 
    L = ['%s=%r' % (key, value)
11202 
      for key, value in self.__dict__.iteritems()]
11203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11204 
 
11205 
  def __eq__(self, other):
11206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11207 
 
11208 
  def __ne__(self, other):
11209 
    return not (self == other)
11210 
 
3064 chandransh 11211 
class markOrdersAsFailed_args:
1596 ankur.sing 11212 
  """
11213 
  Attributes:
3064 chandransh 11214 
   - providerId
11215 
   - returnedOrders
1596 ankur.sing 11216 
  """
11217 
 
11218 
  thrift_spec = (
3064 chandransh 11219 
    None, # 0
11220 
    (1, TType.I64, 'providerId', None, None, ), # 1
11221 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11222 
  )
11223 
 
3064 chandransh 11224 
  def __init__(self, providerId=None, returnedOrders=None,):
11225 
    self.providerId = providerId
11226 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
3064 chandransh 11237 
      if fid == 1:
1596 ankur.sing 11238 
        if ftype == TType.I64:
3064 chandransh 11239 
          self.providerId = iprot.readI64();
1596 ankur.sing 11240 
        else:
11241 
          iprot.skip(ftype)
3064 chandransh 11242 
      elif fid == 2:
11243 
        if ftype == TType.MAP:
11244 
          self.returnedOrders = {}
4133 chandransh 11245 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11246 
          for _i169 in xrange(_size165):
11247 
            _key170 = iprot.readString();
11248 
            _val171 = iprot.readString();
11249 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11250 
          iprot.readMapEnd()
11251 
        else:
11252 
          iprot.skip(ftype)
1596 ankur.sing 11253 
      else:
11254 
        iprot.skip(ftype)
11255 
      iprot.readFieldEnd()
11256 
    iprot.readStructEnd()
11257 
 
11258 
  def write(self, oprot):
11259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11261 
      return
3064 chandransh 11262 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11263 
    if self.providerId is not None:
3064 chandransh 11264 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11265 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11266 
      oprot.writeFieldEnd()
3431 rajveer 11267 
    if self.returnedOrders is not None:
3064 chandransh 11268 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11269 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11270 
      for kiter172,viter173 in self.returnedOrders.items():
11271 
        oprot.writeString(kiter172)
11272 
        oprot.writeString(viter173)
3064 chandransh 11273 
      oprot.writeMapEnd()
11274 
      oprot.writeFieldEnd()
1596 ankur.sing 11275 
    oprot.writeFieldStop()
11276 
    oprot.writeStructEnd()
11277 
 
3431 rajveer 11278 
  def validate(self):
11279 
    return
11280 
 
11281 
 
1596 ankur.sing 11282 
  def __repr__(self):
11283 
    L = ['%s=%r' % (key, value)
11284 
      for key, value in self.__dict__.iteritems()]
11285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11286 
 
11287 
  def __eq__(self, other):
11288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11289 
 
11290 
  def __ne__(self, other):
11291 
    return not (self == other)
11292 
 
3064 chandransh 11293 
class markOrdersAsFailed_result:
11294 
  """
11295 
  Attributes:
11296 
   - ex
11297 
  """
1596 ankur.sing 11298 
 
1627 ankur.sing 11299 
  thrift_spec = (
3064 chandransh 11300 
    None, # 0
11301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11302 
  )
11303 
 
3064 chandransh 11304 
  def __init__(self, ex=None,):
11305 
    self.ex = ex
11306 
 
1627 ankur.sing 11307 
  def read(self, iprot):
11308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11310 
      return
11311 
    iprot.readStructBegin()
11312 
    while True:
11313 
      (fname, ftype, fid) = iprot.readFieldBegin()
11314 
      if ftype == TType.STOP:
11315 
        break
3064 chandransh 11316 
      if fid == 1:
11317 
        if ftype == TType.STRUCT:
11318 
          self.ex = TransactionServiceException()
11319 
          self.ex.read(iprot)
11320 
        else:
11321 
          iprot.skip(ftype)
1627 ankur.sing 11322 
      else:
11323 
        iprot.skip(ftype)
11324 
      iprot.readFieldEnd()
11325 
    iprot.readStructEnd()
11326 
 
11327 
  def write(self, oprot):
11328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11330 
      return
3064 chandransh 11331 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11332 
    if self.ex is not None:
3064 chandransh 11333 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11334 
      self.ex.write(oprot)
11335 
      oprot.writeFieldEnd()
1627 ankur.sing 11336 
    oprot.writeFieldStop()
11337 
    oprot.writeStructEnd()
11338 
 
3431 rajveer 11339 
  def validate(self):
11340 
    return
11341 
 
11342 
 
1627 ankur.sing 11343 
  def __repr__(self):
11344 
    L = ['%s=%r' % (key, value)
11345 
      for key, value in self.__dict__.iteritems()]
11346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11347 
 
11348 
  def __eq__(self, other):
11349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11350 
 
11351 
  def __ne__(self, other):
11352 
    return not (self == other)
11353 
 
3064 chandransh 11354 
class updateNonDeliveryReason_args:
1627 ankur.sing 11355 
  """
11356 
  Attributes:
3064 chandransh 11357 
   - providerId
11358 
   - undeliveredOrders
1627 ankur.sing 11359 
  """
11360 
 
11361 
  thrift_spec = (
3064 chandransh 11362 
    None, # 0
11363 
    (1, TType.I64, 'providerId', None, None, ), # 1
11364 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11365 
  )
11366 
 
3064 chandransh 11367 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11368 
    self.providerId = providerId
11369 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11370 
 
11371 
  def read(self, iprot):
11372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11374 
      return
11375 
    iprot.readStructBegin()
11376 
    while True:
11377 
      (fname, ftype, fid) = iprot.readFieldBegin()
11378 
      if ftype == TType.STOP:
11379 
        break
3064 chandransh 11380 
      if fid == 1:
1627 ankur.sing 11381 
        if ftype == TType.I64:
3064 chandransh 11382 
          self.providerId = iprot.readI64();
1627 ankur.sing 11383 
        else:
11384 
          iprot.skip(ftype)
3064 chandransh 11385 
      elif fid == 2:
11386 
        if ftype == TType.MAP:
11387 
          self.undeliveredOrders = {}
4133 chandransh 11388 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11389 
          for _i178 in xrange(_size174):
11390 
            _key179 = iprot.readString();
11391 
            _val180 = iprot.readString();
11392 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11393 
          iprot.readMapEnd()
11394 
        else:
11395 
          iprot.skip(ftype)
1627 ankur.sing 11396 
      else:
11397 
        iprot.skip(ftype)
11398 
      iprot.readFieldEnd()
11399 
    iprot.readStructEnd()
11400 
 
11401 
  def write(self, oprot):
11402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11404 
      return
3064 chandransh 11405 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11406 
    if self.providerId is not None:
3064 chandransh 11407 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11408 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11409 
      oprot.writeFieldEnd()
3431 rajveer 11410 
    if self.undeliveredOrders is not None:
3064 chandransh 11411 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11412 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11413 
      for kiter181,viter182 in self.undeliveredOrders.items():
11414 
        oprot.writeString(kiter181)
11415 
        oprot.writeString(viter182)
3064 chandransh 11416 
      oprot.writeMapEnd()
11417 
      oprot.writeFieldEnd()
1627 ankur.sing 11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
3431 rajveer 11421 
  def validate(self):
11422 
    return
11423 
 
11424 
 
1627 ankur.sing 11425 
  def __repr__(self):
11426 
    L = ['%s=%r' % (key, value)
11427 
      for key, value in self.__dict__.iteritems()]
11428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11429 
 
11430 
  def __eq__(self, other):
11431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11432 
 
11433 
  def __ne__(self, other):
11434 
    return not (self == other)
11435 
 
3064 chandransh 11436 
class updateNonDeliveryReason_result:
1627 ankur.sing 11437 
  """
11438 
  Attributes:
4581 phani.kuma 11439 
   - success
3064 chandransh 11440 
   - ex
1627 ankur.sing 11441 
  """
11442 
 
11443 
  thrift_spec = (
4581 phani.kuma 11444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11446 
  )
11447 
 
4581 phani.kuma 11448 
  def __init__(self, success=None, ex=None,):
11449 
    self.success = success
3064 chandransh 11450 
    self.ex = ex
1627 ankur.sing 11451 
 
11452 
  def read(self, iprot):
11453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11455 
      return
11456 
    iprot.readStructBegin()
11457 
    while True:
11458 
      (fname, ftype, fid) = iprot.readFieldBegin()
11459 
      if ftype == TType.STOP:
11460 
        break
4581 phani.kuma 11461 
      if fid == 0:
11462 
        if ftype == TType.LIST:
11463 
          self.success = []
11464 
          (_etype186, _size183) = iprot.readListBegin()
11465 
          for _i187 in xrange(_size183):
11466 
            _elem188 = Order()
11467 
            _elem188.read(iprot)
11468 
            self.success.append(_elem188)
11469 
          iprot.readListEnd()
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 1:
3064 chandransh 11473 
        if ftype == TType.STRUCT:
11474 
          self.ex = TransactionServiceException()
11475 
          self.ex.read(iprot)
1627 ankur.sing 11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      else:
11479 
        iprot.skip(ftype)
11480 
      iprot.readFieldEnd()
11481 
    iprot.readStructEnd()
11482 
 
11483 
  def write(self, oprot):
11484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11486 
      return
3064 chandransh 11487 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11488 
    if self.success is not None:
11489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11490 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11491 
      for iter189 in self.success:
11492 
        iter189.write(oprot)
11493 
      oprot.writeListEnd()
11494 
      oprot.writeFieldEnd()
3431 rajveer 11495 
    if self.ex is not None:
3064 chandransh 11496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11497 
      self.ex.write(oprot)
1627 ankur.sing 11498 
      oprot.writeFieldEnd()
11499 
    oprot.writeFieldStop()
11500 
    oprot.writeStructEnd()
11501 
 
3431 rajveer 11502 
  def validate(self):
11503 
    return
11504 
 
11505 
 
1627 ankur.sing 11506 
  def __repr__(self):
11507 
    L = ['%s=%r' % (key, value)
11508 
      for key, value in self.__dict__.iteritems()]
11509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11510 
 
11511 
  def __eq__(self, other):
11512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11513 
 
11514 
  def __ne__(self, other):
11515 
    return not (self == other)
11516 
 
3064 chandransh 11517 
class getUndeliveredOrders_args:
1886 ankur.sing 11518 
  """
11519 
  Attributes:
3064 chandransh 11520 
   - providerId
11521 
   - warehouseId
1886 ankur.sing 11522 
  """
1627 ankur.sing 11523 
 
1886 ankur.sing 11524 
  thrift_spec = (
11525 
    None, # 0
3064 chandransh 11526 
    (1, TType.I64, 'providerId', None, None, ), # 1
11527 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11528 
  )
11529 
 
3064 chandransh 11530 
  def __init__(self, providerId=None, warehouseId=None,):
11531 
    self.providerId = providerId
11532 
    self.warehouseId = warehouseId
1886 ankur.sing 11533 
 
11534 
  def read(self, iprot):
11535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11537 
      return
11538 
    iprot.readStructBegin()
11539 
    while True:
11540 
      (fname, ftype, fid) = iprot.readFieldBegin()
11541 
      if ftype == TType.STOP:
11542 
        break
11543 
      if fid == 1:
11544 
        if ftype == TType.I64:
3064 chandransh 11545 
          self.providerId = iprot.readI64();
1886 ankur.sing 11546 
        else:
11547 
          iprot.skip(ftype)
3064 chandransh 11548 
      elif fid == 2:
11549 
        if ftype == TType.I64:
11550 
          self.warehouseId = iprot.readI64();
11551 
        else:
11552 
          iprot.skip(ftype)
1886 ankur.sing 11553 
      else:
11554 
        iprot.skip(ftype)
11555 
      iprot.readFieldEnd()
11556 
    iprot.readStructEnd()
11557 
 
11558 
  def write(self, oprot):
11559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11561 
      return
3064 chandransh 11562 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11563 
    if self.providerId is not None:
3064 chandransh 11564 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11565 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11566 
      oprot.writeFieldEnd()
3431 rajveer 11567 
    if self.warehouseId is not None:
3064 chandransh 11568 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11569 
      oprot.writeI64(self.warehouseId)
11570 
      oprot.writeFieldEnd()
1886 ankur.sing 11571 
    oprot.writeFieldStop()
11572 
    oprot.writeStructEnd()
11573 
 
3431 rajveer 11574 
  def validate(self):
11575 
    return
11576 
 
11577 
 
1886 ankur.sing 11578 
  def __repr__(self):
11579 
    L = ['%s=%r' % (key, value)
11580 
      for key, value in self.__dict__.iteritems()]
11581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11582 
 
11583 
  def __eq__(self, other):
11584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11585 
 
11586 
  def __ne__(self, other):
11587 
    return not (self == other)
11588 
 
3064 chandransh 11589 
class getUndeliveredOrders_result:
1886 ankur.sing 11590 
  """
11591 
  Attributes:
11592 
   - success
11593 
  """
11594 
 
11595 
  thrift_spec = (
11596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11597 
  )
11598 
 
11599 
  def __init__(self, success=None,):
11600 
    self.success = success
11601 
 
11602 
  def read(self, iprot):
11603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11605 
      return
11606 
    iprot.readStructBegin()
11607 
    while True:
11608 
      (fname, ftype, fid) = iprot.readFieldBegin()
11609 
      if ftype == TType.STOP:
11610 
        break
11611 
      if fid == 0:
11612 
        if ftype == TType.LIST:
11613 
          self.success = []
4581 phani.kuma 11614 
          (_etype193, _size190) = iprot.readListBegin()
11615 
          for _i194 in xrange(_size190):
11616 
            _elem195 = Order()
11617 
            _elem195.read(iprot)
11618 
            self.success.append(_elem195)
1886 ankur.sing 11619 
          iprot.readListEnd()
11620 
        else:
11621 
          iprot.skip(ftype)
11622 
      else:
11623 
        iprot.skip(ftype)
11624 
      iprot.readFieldEnd()
11625 
    iprot.readStructEnd()
11626 
 
11627 
  def write(self, oprot):
11628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11630 
      return
3064 chandransh 11631 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11632 
    if self.success is not None:
1886 ankur.sing 11633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11635 
      for iter196 in self.success:
11636 
        iter196.write(oprot)
1886 ankur.sing 11637 
      oprot.writeListEnd()
11638 
      oprot.writeFieldEnd()
11639 
    oprot.writeFieldStop()
11640 
    oprot.writeStructEnd()
11641 
 
3431 rajveer 11642 
  def validate(self):
11643 
    return
11644 
 
11645 
 
1886 ankur.sing 11646 
  def __repr__(self):
11647 
    L = ['%s=%r' % (key, value)
11648 
      for key, value in self.__dict__.iteritems()]
11649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11650 
 
11651 
  def __eq__(self, other):
11652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11653 
 
11654 
  def __ne__(self, other):
11655 
    return not (self == other)
11656 
 
2536 chandransh 11657 
class toggleDOAFlag_args:
11658 
  """
11659 
  Attributes:
11660 
   - orderId
11661 
  """
1886 ankur.sing 11662 
 
2536 chandransh 11663 
  thrift_spec = (
11664 
    None, # 0
11665 
    (1, TType.I64, 'orderId', None, None, ), # 1
11666 
  )
11667 
 
11668 
  def __init__(self, orderId=None,):
11669 
    self.orderId = orderId
11670 
 
11671 
  def read(self, iprot):
11672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11674 
      return
11675 
    iprot.readStructBegin()
11676 
    while True:
11677 
      (fname, ftype, fid) = iprot.readFieldBegin()
11678 
      if ftype == TType.STOP:
11679 
        break
11680 
      if fid == 1:
11681 
        if ftype == TType.I64:
11682 
          self.orderId = iprot.readI64();
11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      else:
11686 
        iprot.skip(ftype)
11687 
      iprot.readFieldEnd()
11688 
    iprot.readStructEnd()
11689 
 
11690 
  def write(self, oprot):
11691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11693 
      return
11694 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11695 
    if self.orderId is not None:
2536 chandransh 11696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11697 
      oprot.writeI64(self.orderId)
11698 
      oprot.writeFieldEnd()
11699 
    oprot.writeFieldStop()
11700 
    oprot.writeStructEnd()
11701 
 
3431 rajveer 11702 
  def validate(self):
11703 
    return
11704 
 
11705 
 
2536 chandransh 11706 
  def __repr__(self):
11707 
    L = ['%s=%r' % (key, value)
11708 
      for key, value in self.__dict__.iteritems()]
11709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11710 
 
11711 
  def __eq__(self, other):
11712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11713 
 
11714 
  def __ne__(self, other):
11715 
    return not (self == other)
11716 
 
11717 
class toggleDOAFlag_result:
11718 
  """
11719 
  Attributes:
11720 
   - success
11721 
   - ex
11722 
  """
11723 
 
11724 
  thrift_spec = (
11725 
    (0, TType.BOOL, 'success', None, None, ), # 0
11726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11727 
  )
11728 
 
11729 
  def __init__(self, success=None, ex=None,):
11730 
    self.success = success
11731 
    self.ex = ex
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 0:
11743 
        if ftype == TType.BOOL:
11744 
          self.success = iprot.readBool();
11745 
        else:
11746 
          iprot.skip(ftype)
11747 
      elif fid == 1:
11748 
        if ftype == TType.STRUCT:
11749 
          self.ex = TransactionServiceException()
11750 
          self.ex.read(iprot)
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      else:
11754 
        iprot.skip(ftype)
11755 
      iprot.readFieldEnd()
11756 
    iprot.readStructEnd()
11757 
 
11758 
  def write(self, oprot):
11759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11761 
      return
11762 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11763 
    if self.success is not None:
2536 chandransh 11764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11765 
      oprot.writeBool(self.success)
11766 
      oprot.writeFieldEnd()
3431 rajveer 11767 
    if self.ex is not None:
2536 chandransh 11768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11769 
      self.ex.write(oprot)
11770 
      oprot.writeFieldEnd()
11771 
    oprot.writeFieldStop()
11772 
    oprot.writeStructEnd()
11773 
 
3431 rajveer 11774 
  def validate(self):
11775 
    return
11776 
 
11777 
 
2536 chandransh 11778 
  def __repr__(self):
11779 
    L = ['%s=%r' % (key, value)
11780 
      for key, value in self.__dict__.iteritems()]
11781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11782 
 
11783 
  def __eq__(self, other):
11784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11785 
 
11786 
  def __ne__(self, other):
11787 
    return not (self == other)
11788 
 
4712 rajveer 11789 
class markOrderAsDelivered_args:
11790 
  """
11791 
  Attributes:
11792 
   - orderId
11793 
   - deliveryTimestamp
11794 
   - receiver
11795 
  """
11796 
 
11797 
  thrift_spec = None
11798 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
11799 
    self.orderId = orderId
11800 
    self.deliveryTimestamp = deliveryTimestamp
11801 
    self.receiver = receiver
11802 
 
11803 
  def read(self, iprot):
11804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11806 
      return
11807 
    iprot.readStructBegin()
11808 
    while True:
11809 
      (fname, ftype, fid) = iprot.readFieldBegin()
11810 
      if ftype == TType.STOP:
11811 
        break
11812 
      if fid == 1:
11813 
        if ftype == TType.I64:
11814 
          self.orderId = iprot.readI64();
11815 
        else:
11816 
          iprot.skip(ftype)
11817 
      elif fid == 2:
11818 
        if ftype == TType.I64:
11819 
          self.deliveryTimestamp = iprot.readI64();
11820 
        else:
11821 
          iprot.skip(ftype)
11822 
      elif fid == -1:
11823 
        if ftype == TType.STRING:
11824 
          self.receiver = iprot.readString();
11825 
        else:
11826 
          iprot.skip(ftype)
11827 
      else:
11828 
        iprot.skip(ftype)
11829 
      iprot.readFieldEnd()
11830 
    iprot.readStructEnd()
11831 
 
11832 
  def write(self, oprot):
11833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11835 
      return
11836 
    oprot.writeStructBegin('markOrderAsDelivered_args')
11837 
    if self.receiver is not None:
11838 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
11839 
      oprot.writeString(self.receiver)
11840 
      oprot.writeFieldEnd()
11841 
    if self.orderId is not None:
11842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11843 
      oprot.writeI64(self.orderId)
11844 
      oprot.writeFieldEnd()
11845 
    if self.deliveryTimestamp is not None:
11846 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
11847 
      oprot.writeI64(self.deliveryTimestamp)
11848 
      oprot.writeFieldEnd()
11849 
    oprot.writeFieldStop()
11850 
    oprot.writeStructEnd()
11851 
 
11852 
  def validate(self):
11853 
    return
11854 
 
11855 
 
11856 
  def __repr__(self):
11857 
    L = ['%s=%r' % (key, value)
11858 
      for key, value in self.__dict__.iteritems()]
11859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11860 
 
11861 
  def __eq__(self, other):
11862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11863 
 
11864 
  def __ne__(self, other):
11865 
    return not (self == other)
11866 
 
11867 
class markOrderAsDelivered_result:
11868 
  """
11869 
  Attributes:
11870 
   - ex
11871 
  """
11872 
 
11873 
  thrift_spec = (
11874 
    None, # 0
11875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11876 
  )
11877 
 
11878 
  def __init__(self, ex=None,):
11879 
    self.ex = ex
11880 
 
11881 
  def read(self, iprot):
11882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11884 
      return
11885 
    iprot.readStructBegin()
11886 
    while True:
11887 
      (fname, ftype, fid) = iprot.readFieldBegin()
11888 
      if ftype == TType.STOP:
11889 
        break
11890 
      if fid == 1:
11891 
        if ftype == TType.STRUCT:
11892 
          self.ex = TransactionServiceException()
11893 
          self.ex.read(iprot)
11894 
        else:
11895 
          iprot.skip(ftype)
11896 
      else:
11897 
        iprot.skip(ftype)
11898 
      iprot.readFieldEnd()
11899 
    iprot.readStructEnd()
11900 
 
11901 
  def write(self, oprot):
11902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11904 
      return
11905 
    oprot.writeStructBegin('markOrderAsDelivered_result')
11906 
    if self.ex is not None:
11907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11908 
      self.ex.write(oprot)
11909 
      oprot.writeFieldEnd()
11910 
    oprot.writeFieldStop()
11911 
    oprot.writeStructEnd()
11912 
 
11913 
  def validate(self):
11914 
    return
11915 
 
11916 
 
11917 
  def __repr__(self):
11918 
    L = ['%s=%r' % (key, value)
11919 
      for key, value in self.__dict__.iteritems()]
11920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11921 
 
11922 
  def __eq__(self, other):
11923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11924 
 
11925 
  def __ne__(self, other):
11926 
    return not (self == other)
11927 
 
4454 rajveer 11928 
class markOrderDoaRequestReceived_args:
11929 
  """
11930 
  Attributes:
11931 
   - orderId
11932 
  """
11933 
 
11934 
  thrift_spec = (
11935 
    None, # 0
11936 
    (1, TType.I64, 'orderId', None, None, ), # 1
11937 
  )
11938 
 
11939 
  def __init__(self, orderId=None,):
11940 
    self.orderId = orderId
11941 
 
11942 
  def read(self, iprot):
11943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11945 
      return
11946 
    iprot.readStructBegin()
11947 
    while True:
11948 
      (fname, ftype, fid) = iprot.readFieldBegin()
11949 
      if ftype == TType.STOP:
11950 
        break
11951 
      if fid == 1:
11952 
        if ftype == TType.I64:
11953 
          self.orderId = iprot.readI64();
11954 
        else:
11955 
          iprot.skip(ftype)
11956 
      else:
11957 
        iprot.skip(ftype)
11958 
      iprot.readFieldEnd()
11959 
    iprot.readStructEnd()
11960 
 
11961 
  def write(self, oprot):
11962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11964 
      return
11965 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11966 
    if self.orderId is not None:
11967 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11968 
      oprot.writeI64(self.orderId)
11969 
      oprot.writeFieldEnd()
11970 
    oprot.writeFieldStop()
11971 
    oprot.writeStructEnd()
11972 
 
11973 
  def validate(self):
11974 
    return
11975 
 
11976 
 
11977 
  def __repr__(self):
11978 
    L = ['%s=%r' % (key, value)
11979 
      for key, value in self.__dict__.iteritems()]
11980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11981 
 
11982 
  def __eq__(self, other):
11983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11984 
 
11985 
  def __ne__(self, other):
11986 
    return not (self == other)
11987 
 
11988 
class markOrderDoaRequestReceived_result:
11989 
  """
11990 
  Attributes:
11991 
   - success
11992 
   - ex
11993 
  """
11994 
 
11995 
  thrift_spec = (
11996 
    (0, TType.BOOL, 'success', None, None, ), # 0
11997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11998 
  )
11999 
 
12000 
  def __init__(self, success=None, ex=None,):
12001 
    self.success = success
12002 
    self.ex = ex
12003 
 
12004 
  def read(self, iprot):
12005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12007 
      return
12008 
    iprot.readStructBegin()
12009 
    while True:
12010 
      (fname, ftype, fid) = iprot.readFieldBegin()
12011 
      if ftype == TType.STOP:
12012 
        break
12013 
      if fid == 0:
12014 
        if ftype == TType.BOOL:
12015 
          self.success = iprot.readBool();
12016 
        else:
12017 
          iprot.skip(ftype)
12018 
      elif fid == 1:
12019 
        if ftype == TType.STRUCT:
12020 
          self.ex = TransactionServiceException()
12021 
          self.ex.read(iprot)
12022 
        else:
12023 
          iprot.skip(ftype)
12024 
      else:
12025 
        iprot.skip(ftype)
12026 
      iprot.readFieldEnd()
12027 
    iprot.readStructEnd()
12028 
 
12029 
  def write(self, oprot):
12030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12032 
      return
12033 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12034 
    if self.success is not None:
12035 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12036 
      oprot.writeBool(self.success)
12037 
      oprot.writeFieldEnd()
12038 
    if self.ex is not None:
12039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12040 
      self.ex.write(oprot)
12041 
      oprot.writeFieldEnd()
12042 
    oprot.writeFieldStop()
12043 
    oprot.writeStructEnd()
12044 
 
12045 
  def validate(self):
12046 
    return
12047 
 
12048 
 
12049 
  def __repr__(self):
12050 
    L = ['%s=%r' % (key, value)
12051 
      for key, value in self.__dict__.iteritems()]
12052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12053 
 
12054 
  def __eq__(self, other):
12055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12056 
 
12057 
  def __ne__(self, other):
12058 
    return not (self == other)
12059 
 
12060 
class markOrderDoaRequestAuthorized_args:
12061 
  """
12062 
  Attributes:
12063 
   - orderId
12064 
   - isAuthorized
12065 
  """
12066 
 
12067 
  thrift_spec = (
12068 
    None, # 0
12069 
    (1, TType.I64, 'orderId', None, None, ), # 1
12070 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12071 
  )
12072 
 
12073 
  def __init__(self, orderId=None, isAuthorized=None,):
12074 
    self.orderId = orderId
12075 
    self.isAuthorized = isAuthorized
12076 
 
12077 
  def read(self, iprot):
12078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12080 
      return
12081 
    iprot.readStructBegin()
12082 
    while True:
12083 
      (fname, ftype, fid) = iprot.readFieldBegin()
12084 
      if ftype == TType.STOP:
12085 
        break
12086 
      if fid == 1:
12087 
        if ftype == TType.I64:
12088 
          self.orderId = iprot.readI64();
12089 
        else:
12090 
          iprot.skip(ftype)
12091 
      elif fid == 2:
12092 
        if ftype == TType.BOOL:
12093 
          self.isAuthorized = iprot.readBool();
12094 
        else:
12095 
          iprot.skip(ftype)
12096 
      else:
12097 
        iprot.skip(ftype)
12098 
      iprot.readFieldEnd()
12099 
    iprot.readStructEnd()
12100 
 
12101 
  def write(self, oprot):
12102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12104 
      return
12105 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12106 
    if self.orderId is not None:
12107 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12108 
      oprot.writeI64(self.orderId)
12109 
      oprot.writeFieldEnd()
12110 
    if self.isAuthorized is not None:
12111 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12112 
      oprot.writeBool(self.isAuthorized)
12113 
      oprot.writeFieldEnd()
12114 
    oprot.writeFieldStop()
12115 
    oprot.writeStructEnd()
12116 
 
12117 
  def validate(self):
12118 
    return
12119 
 
12120 
 
12121 
  def __repr__(self):
12122 
    L = ['%s=%r' % (key, value)
12123 
      for key, value in self.__dict__.iteritems()]
12124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12125 
 
12126 
  def __eq__(self, other):
12127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12128 
 
12129 
  def __ne__(self, other):
12130 
    return not (self == other)
12131 
 
12132 
class markOrderDoaRequestAuthorized_result:
12133 
  """
12134 
  Attributes:
12135 
   - success
12136 
   - ex
12137 
  """
12138 
 
12139 
  thrift_spec = (
12140 
    (0, TType.BOOL, 'success', None, None, ), # 0
12141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12142 
  )
12143 
 
12144 
  def __init__(self, success=None, ex=None,):
12145 
    self.success = success
12146 
    self.ex = ex
12147 
 
12148 
  def read(self, iprot):
12149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12151 
      return
12152 
    iprot.readStructBegin()
12153 
    while True:
12154 
      (fname, ftype, fid) = iprot.readFieldBegin()
12155 
      if ftype == TType.STOP:
12156 
        break
12157 
      if fid == 0:
12158 
        if ftype == TType.BOOL:
12159 
          self.success = iprot.readBool();
12160 
        else:
12161 
          iprot.skip(ftype)
12162 
      elif fid == 1:
12163 
        if ftype == TType.STRUCT:
12164 
          self.ex = TransactionServiceException()
12165 
          self.ex.read(iprot)
12166 
        else:
12167 
          iprot.skip(ftype)
12168 
      else:
12169 
        iprot.skip(ftype)
12170 
      iprot.readFieldEnd()
12171 
    iprot.readStructEnd()
12172 
 
12173 
  def write(self, oprot):
12174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12176 
      return
12177 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12178 
    if self.success is not None:
12179 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12180 
      oprot.writeBool(self.success)
12181 
      oprot.writeFieldEnd()
12182 
    if self.ex is not None:
12183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12184 
      self.ex.write(oprot)
12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
4488 rajveer 12204 
class markOrderReturnRequestReceived_args:
12205 
  """
12206 
  Attributes:
12207 
   - orderId
12208 
  """
12209 
 
12210 
  thrift_spec = (
12211 
    None, # 0
12212 
    (1, TType.I64, 'orderId', None, None, ), # 1
12213 
  )
12214 
 
12215 
  def __init__(self, orderId=None,):
12216 
    self.orderId = orderId
12217 
 
12218 
  def read(self, iprot):
12219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12221 
      return
12222 
    iprot.readStructBegin()
12223 
    while True:
12224 
      (fname, ftype, fid) = iprot.readFieldBegin()
12225 
      if ftype == TType.STOP:
12226 
        break
12227 
      if fid == 1:
12228 
        if ftype == TType.I64:
12229 
          self.orderId = iprot.readI64();
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('markOrderReturnRequestReceived_args')
12242 
    if self.orderId is not None:
12243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12244 
      oprot.writeI64(self.orderId)
12245 
      oprot.writeFieldEnd()
12246 
    oprot.writeFieldStop()
12247 
    oprot.writeStructEnd()
12248 
 
12249 
  def validate(self):
12250 
    return
12251 
 
12252 
 
12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
12264 
class markOrderReturnRequestReceived_result:
12265 
  """
12266 
  Attributes:
12267 
   - success
12268 
   - ex
12269 
  """
12270 
 
12271 
  thrift_spec = (
12272 
    (0, TType.BOOL, 'success', None, None, ), # 0
12273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12274 
  )
12275 
 
12276 
  def __init__(self, success=None, ex=None,):
12277 
    self.success = success
12278 
    self.ex = ex
12279 
 
12280 
  def read(self, iprot):
12281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12283 
      return
12284 
    iprot.readStructBegin()
12285 
    while True:
12286 
      (fname, ftype, fid) = iprot.readFieldBegin()
12287 
      if ftype == TType.STOP:
12288 
        break
12289 
      if fid == 0:
12290 
        if ftype == TType.BOOL:
12291 
          self.success = iprot.readBool();
12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      elif fid == 1:
12295 
        if ftype == TType.STRUCT:
12296 
          self.ex = TransactionServiceException()
12297 
          self.ex.read(iprot)
12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
12309 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12310 
    if self.success is not None:
12311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12312 
      oprot.writeBool(self.success)
12313 
      oprot.writeFieldEnd()
12314 
    if self.ex is not None:
12315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12316 
      self.ex.write(oprot)
12317 
      oprot.writeFieldEnd()
12318 
    oprot.writeFieldStop()
12319 
    oprot.writeStructEnd()
12320 
 
12321 
  def validate(self):
12322 
    return
12323 
 
12324 
 
12325 
  def __repr__(self):
12326 
    L = ['%s=%r' % (key, value)
12327 
      for key, value in self.__dict__.iteritems()]
12328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12329 
 
12330 
  def __eq__(self, other):
12331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12332 
 
12333 
  def __ne__(self, other):
12334 
    return not (self == other)
12335 
 
12336 
class markOrderReturnRequestAuthorized_args:
12337 
  """
12338 
  Attributes:
12339 
   - orderId
12340 
   - isAuthorized
12341 
  """
12342 
 
12343 
  thrift_spec = (
12344 
    None, # 0
12345 
    (1, TType.I64, 'orderId', None, None, ), # 1
12346 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12347 
  )
12348 
 
12349 
  def __init__(self, orderId=None, isAuthorized=None,):
12350 
    self.orderId = orderId
12351 
    self.isAuthorized = isAuthorized
12352 
 
12353 
  def read(self, iprot):
12354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12356 
      return
12357 
    iprot.readStructBegin()
12358 
    while True:
12359 
      (fname, ftype, fid) = iprot.readFieldBegin()
12360 
      if ftype == TType.STOP:
12361 
        break
12362 
      if fid == 1:
12363 
        if ftype == TType.I64:
12364 
          self.orderId = iprot.readI64();
12365 
        else:
12366 
          iprot.skip(ftype)
12367 
      elif fid == 2:
12368 
        if ftype == TType.BOOL:
12369 
          self.isAuthorized = iprot.readBool();
12370 
        else:
12371 
          iprot.skip(ftype)
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
12381 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12382 
    if self.orderId is not None:
12383 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12384 
      oprot.writeI64(self.orderId)
12385 
      oprot.writeFieldEnd()
12386 
    if self.isAuthorized is not None:
12387 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12388 
      oprot.writeBool(self.isAuthorized)
12389 
      oprot.writeFieldEnd()
12390 
    oprot.writeFieldStop()
12391 
    oprot.writeStructEnd()
12392 
 
12393 
  def validate(self):
12394 
    return
12395 
 
12396 
 
12397 
  def __repr__(self):
12398 
    L = ['%s=%r' % (key, value)
12399 
      for key, value in self.__dict__.iteritems()]
12400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12401 
 
12402 
  def __eq__(self, other):
12403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12404 
 
12405 
  def __ne__(self, other):
12406 
    return not (self == other)
12407 
 
12408 
class markOrderReturnRequestAuthorized_result:
12409 
  """
12410 
  Attributes:
12411 
   - success
12412 
   - ex
12413 
  """
12414 
 
12415 
  thrift_spec = (
12416 
    (0, TType.BOOL, 'success', None, None, ), # 0
12417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12418 
  )
12419 
 
12420 
  def __init__(self, success=None, ex=None,):
12421 
    self.success = success
12422 
    self.ex = ex
12423 
 
12424 
  def read(self, iprot):
12425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12427 
      return
12428 
    iprot.readStructBegin()
12429 
    while True:
12430 
      (fname, ftype, fid) = iprot.readFieldBegin()
12431 
      if ftype == TType.STOP:
12432 
        break
12433 
      if fid == 0:
12434 
        if ftype == TType.BOOL:
12435 
          self.success = iprot.readBool();
12436 
        else:
12437 
          iprot.skip(ftype)
12438 
      elif fid == 1:
12439 
        if ftype == TType.STRUCT:
12440 
          self.ex = TransactionServiceException()
12441 
          self.ex.read(iprot)
12442 
        else:
12443 
          iprot.skip(ftype)
12444 
      else:
12445 
        iprot.skip(ftype)
12446 
      iprot.readFieldEnd()
12447 
    iprot.readStructEnd()
12448 
 
12449 
  def write(self, oprot):
12450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12452 
      return
12453 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12454 
    if self.success is not None:
12455 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12456 
      oprot.writeBool(self.success)
12457 
      oprot.writeFieldEnd()
12458 
    if self.ex is not None:
12459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12460 
      self.ex.write(oprot)
12461 
      oprot.writeFieldEnd()
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
2536 chandransh 12480 
class requestPickupNumber_args:
12481 
  """
12482 
  Attributes:
12483 
   - orderId
4579 rajveer 12484 
   - providerId
2536 chandransh 12485 
  """
12486 
 
12487 
  thrift_spec = (
12488 
    None, # 0
12489 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12490 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12491 
  )
12492 
 
4579 rajveer 12493 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12494 
    self.orderId = orderId
4579 rajveer 12495 
    self.providerId = providerId
2536 chandransh 12496 
 
12497 
  def read(self, iprot):
12498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12500 
      return
12501 
    iprot.readStructBegin()
12502 
    while True:
12503 
      (fname, ftype, fid) = iprot.readFieldBegin()
12504 
      if ftype == TType.STOP:
12505 
        break
12506 
      if fid == 1:
12507 
        if ftype == TType.I64:
12508 
          self.orderId = iprot.readI64();
12509 
        else:
12510 
          iprot.skip(ftype)
4579 rajveer 12511 
      elif fid == 2:
12512 
        if ftype == TType.I64:
12513 
          self.providerId = iprot.readI64();
12514 
        else:
12515 
          iprot.skip(ftype)
2536 chandransh 12516 
      else:
12517 
        iprot.skip(ftype)
12518 
      iprot.readFieldEnd()
12519 
    iprot.readStructEnd()
12520 
 
12521 
  def write(self, oprot):
12522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12524 
      return
12525 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12526 
    if self.orderId is not None:
2536 chandransh 12527 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12528 
      oprot.writeI64(self.orderId)
12529 
      oprot.writeFieldEnd()
4579 rajveer 12530 
    if self.providerId is not None:
12531 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12532 
      oprot.writeI64(self.providerId)
12533 
      oprot.writeFieldEnd()
2536 chandransh 12534 
    oprot.writeFieldStop()
12535 
    oprot.writeStructEnd()
12536 
 
3431 rajveer 12537 
  def validate(self):
12538 
    return
12539 
 
12540 
 
2536 chandransh 12541 
  def __repr__(self):
12542 
    L = ['%s=%r' % (key, value)
12543 
      for key, value in self.__dict__.iteritems()]
12544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12545 
 
12546 
  def __eq__(self, other):
12547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12548 
 
12549 
  def __ne__(self, other):
12550 
    return not (self == other)
12551 
 
12552 
class requestPickupNumber_result:
12553 
  """
12554 
  Attributes:
12555 
   - success
12556 
   - ex
12557 
  """
12558 
 
12559 
  thrift_spec = (
12560 
    (0, TType.BOOL, 'success', None, None, ), # 0
12561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12562 
  )
12563 
 
12564 
  def __init__(self, success=None, ex=None,):
12565 
    self.success = success
12566 
    self.ex = ex
12567 
 
12568 
  def read(self, iprot):
12569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12571 
      return
12572 
    iprot.readStructBegin()
12573 
    while True:
12574 
      (fname, ftype, fid) = iprot.readFieldBegin()
12575 
      if ftype == TType.STOP:
12576 
        break
12577 
      if fid == 0:
12578 
        if ftype == TType.BOOL:
12579 
          self.success = iprot.readBool();
12580 
        else:
12581 
          iprot.skip(ftype)
12582 
      elif fid == 1:
12583 
        if ftype == TType.STRUCT:
12584 
          self.ex = TransactionServiceException()
12585 
          self.ex.read(iprot)
12586 
        else:
12587 
          iprot.skip(ftype)
12588 
      else:
12589 
        iprot.skip(ftype)
12590 
      iprot.readFieldEnd()
12591 
    iprot.readStructEnd()
12592 
 
12593 
  def write(self, oprot):
12594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12596 
      return
12597 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12598 
    if self.success is not None:
2536 chandransh 12599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12600 
      oprot.writeBool(self.success)
12601 
      oprot.writeFieldEnd()
3431 rajveer 12602 
    if self.ex is not None:
2536 chandransh 12603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12604 
      self.ex.write(oprot)
12605 
      oprot.writeFieldEnd()
12606 
    oprot.writeFieldStop()
12607 
    oprot.writeStructEnd()
12608 
 
3431 rajveer 12609 
  def validate(self):
12610 
    return
12611 
 
12612 
 
2536 chandransh 12613 
  def __repr__(self):
12614 
    L = ['%s=%r' % (key, value)
12615 
      for key, value in self.__dict__.iteritems()]
12616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12617 
 
12618 
  def __eq__(self, other):
12619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12620 
 
12621 
  def __ne__(self, other):
12622 
    return not (self == other)
12623 
 
12624 
class authorizePickup_args:
12625 
  """
12626 
  Attributes:
12627 
   - orderId
12628 
   - pickupNumber
4602 rajveer 12629 
   - providerId
2536 chandransh 12630 
  """
12631 
 
12632 
  thrift_spec = (
12633 
    None, # 0
12634 
    (1, TType.I64, 'orderId', None, None, ), # 1
12635 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12636 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12637 
  )
12638 
 
4602 rajveer 12639 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12640 
    self.orderId = orderId
12641 
    self.pickupNumber = pickupNumber
4602 rajveer 12642 
    self.providerId = providerId
2536 chandransh 12643 
 
12644 
  def read(self, iprot):
12645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12647 
      return
12648 
    iprot.readStructBegin()
12649 
    while True:
12650 
      (fname, ftype, fid) = iprot.readFieldBegin()
12651 
      if ftype == TType.STOP:
12652 
        break
12653 
      if fid == 1:
12654 
        if ftype == TType.I64:
12655 
          self.orderId = iprot.readI64();
12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      elif fid == 2:
12659 
        if ftype == TType.STRING:
12660 
          self.pickupNumber = iprot.readString();
12661 
        else:
12662 
          iprot.skip(ftype)
4602 rajveer 12663 
      elif fid == 3:
12664 
        if ftype == TType.I64:
12665 
          self.providerId = iprot.readI64();
12666 
        else:
12667 
          iprot.skip(ftype)
2536 chandransh 12668 
      else:
12669 
        iprot.skip(ftype)
12670 
      iprot.readFieldEnd()
12671 
    iprot.readStructEnd()
12672 
 
12673 
  def write(self, oprot):
12674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12676 
      return
12677 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12678 
    if self.orderId is not None:
2536 chandransh 12679 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12680 
      oprot.writeI64(self.orderId)
12681 
      oprot.writeFieldEnd()
3431 rajveer 12682 
    if self.pickupNumber is not None:
2536 chandransh 12683 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12684 
      oprot.writeString(self.pickupNumber)
12685 
      oprot.writeFieldEnd()
4602 rajveer 12686 
    if self.providerId is not None:
12687 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12688 
      oprot.writeI64(self.providerId)
12689 
      oprot.writeFieldEnd()
2536 chandransh 12690 
    oprot.writeFieldStop()
12691 
    oprot.writeStructEnd()
12692 
 
3431 rajveer 12693 
  def validate(self):
12694 
    return
12695 
 
12696 
 
2536 chandransh 12697 
  def __repr__(self):
12698 
    L = ['%s=%r' % (key, value)
12699 
      for key, value in self.__dict__.iteritems()]
12700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12701 
 
12702 
  def __eq__(self, other):
12703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12704 
 
12705 
  def __ne__(self, other):
12706 
    return not (self == other)
12707 
 
12708 
class authorizePickup_result:
12709 
  """
12710 
  Attributes:
12711 
   - success
12712 
   - ex
12713 
  """
12714 
 
12715 
  thrift_spec = (
12716 
    (0, TType.BOOL, 'success', None, None, ), # 0
12717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12718 
  )
12719 
 
12720 
  def __init__(self, success=None, ex=None,):
12721 
    self.success = success
12722 
    self.ex = ex
12723 
 
12724 
  def read(self, iprot):
12725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12727 
      return
12728 
    iprot.readStructBegin()
12729 
    while True:
12730 
      (fname, ftype, fid) = iprot.readFieldBegin()
12731 
      if ftype == TType.STOP:
12732 
        break
12733 
      if fid == 0:
12734 
        if ftype == TType.BOOL:
12735 
          self.success = iprot.readBool();
12736 
        else:
12737 
          iprot.skip(ftype)
12738 
      elif fid == 1:
12739 
        if ftype == TType.STRUCT:
12740 
          self.ex = TransactionServiceException()
12741 
          self.ex.read(iprot)
12742 
        else:
12743 
          iprot.skip(ftype)
12744 
      else:
12745 
        iprot.skip(ftype)
12746 
      iprot.readFieldEnd()
12747 
    iprot.readStructEnd()
12748 
 
12749 
  def write(self, oprot):
12750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12752 
      return
12753 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12754 
    if self.success is not None:
2536 chandransh 12755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12756 
      oprot.writeBool(self.success)
12757 
      oprot.writeFieldEnd()
3431 rajveer 12758 
    if self.ex is not None:
2536 chandransh 12759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12760 
      self.ex.write(oprot)
12761 
      oprot.writeFieldEnd()
12762 
    oprot.writeFieldStop()
12763 
    oprot.writeStructEnd()
12764 
 
3431 rajveer 12765 
  def validate(self):
12766 
    return
12767 
 
12768 
 
2536 chandransh 12769 
  def __repr__(self):
12770 
    L = ['%s=%r' % (key, value)
12771 
      for key, value in self.__dict__.iteritems()]
12772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12773 
 
12774 
  def __eq__(self, other):
12775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12776 
 
12777 
  def __ne__(self, other):
12778 
    return not (self == other)
12779 
 
2764 chandransh 12780 
class markDoasAsPickedUp_args:
12781 
  """
12782 
  Attributes:
12783 
   - providerId
12784 
   - pickupDetails
12785 
  """
12786 
 
12787 
  thrift_spec = (
12788 
    None, # 0
12789 
    (1, TType.I64, 'providerId', None, None, ), # 1
12790 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12791 
  )
12792 
 
12793 
  def __init__(self, providerId=None, pickupDetails=None,):
12794 
    self.providerId = providerId
12795 
    self.pickupDetails = pickupDetails
12796 
 
12797 
  def read(self, iprot):
12798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12800 
      return
12801 
    iprot.readStructBegin()
12802 
    while True:
12803 
      (fname, ftype, fid) = iprot.readFieldBegin()
12804 
      if ftype == TType.STOP:
12805 
        break
12806 
      if fid == 1:
12807 
        if ftype == TType.I64:
12808 
          self.providerId = iprot.readI64();
12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      elif fid == 2:
12812 
        if ftype == TType.MAP:
12813 
          self.pickupDetails = {}
4581 phani.kuma 12814 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12815 
          for _i201 in xrange(_size197):
12816 
            _key202 = iprot.readString();
12817 
            _val203 = iprot.readString();
12818 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12819 
          iprot.readMapEnd()
12820 
        else:
12821 
          iprot.skip(ftype)
12822 
      else:
12823 
        iprot.skip(ftype)
12824 
      iprot.readFieldEnd()
12825 
    iprot.readStructEnd()
12826 
 
12827 
  def write(self, oprot):
12828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12830 
      return
12831 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12832 
    if self.providerId is not None:
2764 chandransh 12833 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12834 
      oprot.writeI64(self.providerId)
12835 
      oprot.writeFieldEnd()
3431 rajveer 12836 
    if self.pickupDetails is not None:
2764 chandransh 12837 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12838 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12839 
      for kiter204,viter205 in self.pickupDetails.items():
12840 
        oprot.writeString(kiter204)
12841 
        oprot.writeString(viter205)
2764 chandransh 12842 
      oprot.writeMapEnd()
12843 
      oprot.writeFieldEnd()
12844 
    oprot.writeFieldStop()
12845 
    oprot.writeStructEnd()
12846 
 
3431 rajveer 12847 
  def validate(self):
12848 
    return
12849 
 
12850 
 
2764 chandransh 12851 
  def __repr__(self):
12852 
    L = ['%s=%r' % (key, value)
12853 
      for key, value in self.__dict__.iteritems()]
12854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12855 
 
12856 
  def __eq__(self, other):
12857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12858 
 
12859 
  def __ne__(self, other):
12860 
    return not (self == other)
12861 
 
12862 
class markDoasAsPickedUp_result:
12863 
  """
12864 
  Attributes:
12865 
   - success
12866 
  """
12867 
 
12868 
  thrift_spec = (
12869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12870 
  )
12871 
 
12872 
  def __init__(self, success=None,):
12873 
    self.success = success
12874 
 
12875 
  def read(self, iprot):
12876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12878 
      return
12879 
    iprot.readStructBegin()
12880 
    while True:
12881 
      (fname, ftype, fid) = iprot.readFieldBegin()
12882 
      if ftype == TType.STOP:
12883 
        break
12884 
      if fid == 0:
12885 
        if ftype == TType.LIST:
12886 
          self.success = []
4581 phani.kuma 12887 
          (_etype209, _size206) = iprot.readListBegin()
12888 
          for _i210 in xrange(_size206):
12889 
            _elem211 = Order()
12890 
            _elem211.read(iprot)
12891 
            self.success.append(_elem211)
2764 chandransh 12892 
          iprot.readListEnd()
12893 
        else:
12894 
          iprot.skip(ftype)
12895 
      else:
12896 
        iprot.skip(ftype)
12897 
      iprot.readFieldEnd()
12898 
    iprot.readStructEnd()
12899 
 
12900 
  def write(self, oprot):
12901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12903 
      return
12904 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12905 
    if self.success is not None:
2764 chandransh 12906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12907 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12908 
      for iter212 in self.success:
12909 
        iter212.write(oprot)
2764 chandransh 12910 
      oprot.writeListEnd()
12911 
      oprot.writeFieldEnd()
12912 
    oprot.writeFieldStop()
12913 
    oprot.writeStructEnd()
12914 
 
3431 rajveer 12915 
  def validate(self):
12916 
    return
12917 
 
12918 
 
2764 chandransh 12919 
  def __repr__(self):
12920 
    L = ['%s=%r' % (key, value)
12921 
      for key, value in self.__dict__.iteritems()]
12922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12923 
 
12924 
  def __eq__(self, other):
12925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12926 
 
12927 
  def __ne__(self, other):
12928 
    return not (self == other)
12929 
 
2616 chandransh 12930 
class receiveReturn_args:
2591 chandransh 12931 
  """
12932 
  Attributes:
12933 
   - orderId
4479 rajveer 12934 
   - receiveCondition
2591 chandransh 12935 
  """
2536 chandransh 12936 
 
2591 chandransh 12937 
  thrift_spec = (
12938 
    None, # 0
12939 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12940 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12941 
  )
12942 
 
4479 rajveer 12943 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12944 
    self.orderId = orderId
4479 rajveer 12945 
    self.receiveCondition = receiveCondition
2591 chandransh 12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      if fid == 1:
12957 
        if ftype == TType.I64:
12958 
          self.orderId = iprot.readI64();
12959 
        else:
12960 
          iprot.skip(ftype)
4479 rajveer 12961 
      elif fid == 2:
12962 
        if ftype == TType.I64:
12963 
          self.receiveCondition = iprot.readI64();
12964 
        else:
12965 
          iprot.skip(ftype)
2591 chandransh 12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
2616 chandransh 12975 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12976 
    if self.orderId is not None:
2591 chandransh 12977 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12978 
      oprot.writeI64(self.orderId)
12979 
      oprot.writeFieldEnd()
4479 rajveer 12980 
    if self.receiveCondition is not None:
12981 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12982 
      oprot.writeI64(self.receiveCondition)
12983 
      oprot.writeFieldEnd()
2591 chandransh 12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
3431 rajveer 12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
2591 chandransh 12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
2616 chandransh 13002 
class receiveReturn_result:
2591 chandransh 13003 
  """
13004 
  Attributes:
13005 
   - success
13006 
   - ex
13007 
  """
13008 
 
13009 
  thrift_spec = (
13010 
    (0, TType.BOOL, 'success', None, None, ), # 0
13011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13012 
  )
13013 
 
13014 
  def __init__(self, success=None, ex=None,):
13015 
    self.success = success
13016 
    self.ex = ex
13017 
 
13018 
  def read(self, iprot):
13019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13021 
      return
13022 
    iprot.readStructBegin()
13023 
    while True:
13024 
      (fname, ftype, fid) = iprot.readFieldBegin()
13025 
      if ftype == TType.STOP:
13026 
        break
13027 
      if fid == 0:
13028 
        if ftype == TType.BOOL:
13029 
          self.success = iprot.readBool();
13030 
        else:
13031 
          iprot.skip(ftype)
13032 
      elif fid == 1:
13033 
        if ftype == TType.STRUCT:
13034 
          self.ex = TransactionServiceException()
13035 
          self.ex.read(iprot)
13036 
        else:
13037 
          iprot.skip(ftype)
13038 
      else:
13039 
        iprot.skip(ftype)
13040 
      iprot.readFieldEnd()
13041 
    iprot.readStructEnd()
13042 
 
13043 
  def write(self, oprot):
13044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13046 
      return
2616 chandransh 13047 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13048 
    if self.success is not None:
2591 chandransh 13049 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13050 
      oprot.writeBool(self.success)
13051 
      oprot.writeFieldEnd()
3431 rajveer 13052 
    if self.ex is not None:
2591 chandransh 13053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13054 
      self.ex.write(oprot)
13055 
      oprot.writeFieldEnd()
13056 
    oprot.writeFieldStop()
13057 
    oprot.writeStructEnd()
13058 
 
3431 rajveer 13059 
  def validate(self):
13060 
    return
13061 
 
13062 
 
2591 chandransh 13063 
  def __repr__(self):
13064 
    L = ['%s=%r' % (key, value)
13065 
      for key, value in self.__dict__.iteritems()]
13066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13067 
 
13068 
  def __eq__(self, other):
13069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13070 
 
13071 
  def __ne__(self, other):
13072 
    return not (self == other)
13073 
 
13074 
class validateDoa_args:
13075 
  """
13076 
  Attributes:
13077 
   - orderId
13078 
   - isValid
13079 
  """
13080 
 
13081 
  thrift_spec = (
13082 
    None, # 0
13083 
    (1, TType.I64, 'orderId', None, None, ), # 1
13084 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13085 
  )
13086 
 
13087 
  def __init__(self, orderId=None, isValid=None,):
13088 
    self.orderId = orderId
13089 
    self.isValid = isValid
13090 
 
13091 
  def read(self, iprot):
13092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13094 
      return
13095 
    iprot.readStructBegin()
13096 
    while True:
13097 
      (fname, ftype, fid) = iprot.readFieldBegin()
13098 
      if ftype == TType.STOP:
13099 
        break
13100 
      if fid == 1:
13101 
        if ftype == TType.I64:
13102 
          self.orderId = iprot.readI64();
13103 
        else:
13104 
          iprot.skip(ftype)
13105 
      elif fid == 2:
13106 
        if ftype == TType.BOOL:
13107 
          self.isValid = iprot.readBool();
13108 
        else:
13109 
          iprot.skip(ftype)
13110 
      else:
13111 
        iprot.skip(ftype)
13112 
      iprot.readFieldEnd()
13113 
    iprot.readStructEnd()
13114 
 
13115 
  def write(self, oprot):
13116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13118 
      return
13119 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13120 
    if self.orderId is not None:
2591 chandransh 13121 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13122 
      oprot.writeI64(self.orderId)
13123 
      oprot.writeFieldEnd()
3431 rajveer 13124 
    if self.isValid is not None:
2591 chandransh 13125 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13126 
      oprot.writeBool(self.isValid)
13127 
      oprot.writeFieldEnd()
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
3431 rajveer 13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
2591 chandransh 13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class validateDoa_result:
13147 
  """
13148 
  Attributes:
13149 
   - success
13150 
   - ex
13151 
  """
13152 
 
13153 
  thrift_spec = (
13154 
    (0, TType.BOOL, 'success', None, None, ), # 0
13155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13156 
  )
13157 
 
13158 
  def __init__(self, success=None, ex=None,):
13159 
    self.success = success
13160 
    self.ex = ex
13161 
 
13162 
  def read(self, iprot):
13163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13165 
      return
13166 
    iprot.readStructBegin()
13167 
    while True:
13168 
      (fname, ftype, fid) = iprot.readFieldBegin()
13169 
      if ftype == TType.STOP:
13170 
        break
13171 
      if fid == 0:
13172 
        if ftype == TType.BOOL:
13173 
          self.success = iprot.readBool();
13174 
        else:
13175 
          iprot.skip(ftype)
13176 
      elif fid == 1:
13177 
        if ftype == TType.STRUCT:
13178 
          self.ex = TransactionServiceException()
13179 
          self.ex.read(iprot)
13180 
        else:
13181 
          iprot.skip(ftype)
13182 
      else:
13183 
        iprot.skip(ftype)
13184 
      iprot.readFieldEnd()
13185 
    iprot.readStructEnd()
13186 
 
13187 
  def write(self, oprot):
13188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13190 
      return
13191 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13192 
    if self.success is not None:
2591 chandransh 13193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13194 
      oprot.writeBool(self.success)
13195 
      oprot.writeFieldEnd()
3431 rajveer 13196 
    if self.ex is not None:
2591 chandransh 13197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13198 
      self.ex.write(oprot)
13199 
      oprot.writeFieldEnd()
13200 
    oprot.writeFieldStop()
13201 
    oprot.writeStructEnd()
13202 
 
3431 rajveer 13203 
  def validate(self):
13204 
    return
13205 
 
13206 
 
2591 chandransh 13207 
  def __repr__(self):
13208 
    L = ['%s=%r' % (key, value)
13209 
      for key, value in self.__dict__.iteritems()]
13210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13211 
 
13212 
  def __eq__(self, other):
13213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13214 
 
13215 
  def __ne__(self, other):
13216 
    return not (self == other)
13217 
 
4495 rajveer 13218 
class validateReturnProduct_args:
13219 
  """
13220 
  Attributes:
13221 
   - orderId
13222 
   - isUsable
13223 
  """
13224 
 
13225 
  thrift_spec = (
13226 
    None, # 0
13227 
    (1, TType.I64, 'orderId', None, None, ), # 1
13228 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13229 
  )
13230 
 
13231 
  def __init__(self, orderId=None, isUsable=None,):
13232 
    self.orderId = orderId
13233 
    self.isUsable = isUsable
13234 
 
13235 
  def read(self, iprot):
13236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13238 
      return
13239 
    iprot.readStructBegin()
13240 
    while True:
13241 
      (fname, ftype, fid) = iprot.readFieldBegin()
13242 
      if ftype == TType.STOP:
13243 
        break
13244 
      if fid == 1:
13245 
        if ftype == TType.I64:
13246 
          self.orderId = iprot.readI64();
13247 
        else:
13248 
          iprot.skip(ftype)
13249 
      elif fid == 2:
13250 
        if ftype == TType.BOOL:
13251 
          self.isUsable = iprot.readBool();
13252 
        else:
13253 
          iprot.skip(ftype)
13254 
      else:
13255 
        iprot.skip(ftype)
13256 
      iprot.readFieldEnd()
13257 
    iprot.readStructEnd()
13258 
 
13259 
  def write(self, oprot):
13260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13262 
      return
13263 
    oprot.writeStructBegin('validateReturnProduct_args')
13264 
    if self.orderId is not None:
13265 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13266 
      oprot.writeI64(self.orderId)
13267 
      oprot.writeFieldEnd()
13268 
    if self.isUsable is not None:
13269 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13270 
      oprot.writeBool(self.isUsable)
13271 
      oprot.writeFieldEnd()
13272 
    oprot.writeFieldStop()
13273 
    oprot.writeStructEnd()
13274 
 
13275 
  def validate(self):
13276 
    return
13277 
 
13278 
 
13279 
  def __repr__(self):
13280 
    L = ['%s=%r' % (key, value)
13281 
      for key, value in self.__dict__.iteritems()]
13282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13283 
 
13284 
  def __eq__(self, other):
13285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13286 
 
13287 
  def __ne__(self, other):
13288 
    return not (self == other)
13289 
 
13290 
class validateReturnProduct_result:
13291 
  """
13292 
  Attributes:
13293 
   - success
13294 
   - ex
13295 
  """
13296 
 
13297 
  thrift_spec = (
13298 
    (0, TType.BOOL, 'success', None, None, ), # 0
13299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13300 
  )
13301 
 
13302 
  def __init__(self, success=None, ex=None,):
13303 
    self.success = success
13304 
    self.ex = ex
13305 
 
13306 
  def read(self, iprot):
13307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13309 
      return
13310 
    iprot.readStructBegin()
13311 
    while True:
13312 
      (fname, ftype, fid) = iprot.readFieldBegin()
13313 
      if ftype == TType.STOP:
13314 
        break
13315 
      if fid == 0:
13316 
        if ftype == TType.BOOL:
13317 
          self.success = iprot.readBool();
13318 
        else:
13319 
          iprot.skip(ftype)
13320 
      elif fid == 1:
13321 
        if ftype == TType.STRUCT:
13322 
          self.ex = TransactionServiceException()
13323 
          self.ex.read(iprot)
13324 
        else:
13325 
          iprot.skip(ftype)
13326 
      else:
13327 
        iprot.skip(ftype)
13328 
      iprot.readFieldEnd()
13329 
    iprot.readStructEnd()
13330 
 
13331 
  def write(self, oprot):
13332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13334 
      return
13335 
    oprot.writeStructBegin('validateReturnProduct_result')
13336 
    if self.success is not None:
13337 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13338 
      oprot.writeBool(self.success)
13339 
      oprot.writeFieldEnd()
13340 
    if self.ex is not None:
13341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13342 
      self.ex.write(oprot)
13343 
      oprot.writeFieldEnd()
13344 
    oprot.writeFieldStop()
13345 
    oprot.writeStructEnd()
13346 
 
13347 
  def validate(self):
13348 
    return
13349 
 
13350 
 
13351 
  def __repr__(self):
13352 
    L = ['%s=%r' % (key, value)
13353 
      for key, value in self.__dict__.iteritems()]
13354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13355 
 
13356 
  def __eq__(self, other):
13357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13358 
 
13359 
  def __ne__(self, other):
13360 
    return not (self == other)
13361 
 
2616 chandransh 13362 
class reshipOrder_args:
13363 
  """
13364 
  Attributes:
13365 
   - orderId
13366 
  """
2591 chandransh 13367 
 
2616 chandransh 13368 
  thrift_spec = (
13369 
    None, # 0
13370 
    (1, TType.I64, 'orderId', None, None, ), # 1
13371 
  )
13372 
 
13373 
  def __init__(self, orderId=None,):
13374 
    self.orderId = orderId
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 == 1:
13386 
        if ftype == TType.I64:
13387 
          self.orderId = iprot.readI64();
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
13399 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13400 
    if self.orderId is not None:
2616 chandransh 13401 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13402 
      oprot.writeI64(self.orderId)
13403 
      oprot.writeFieldEnd()
13404 
    oprot.writeFieldStop()
13405 
    oprot.writeStructEnd()
13406 
 
3431 rajveer 13407 
  def validate(self):
13408 
    return
13409 
 
13410 
 
2616 chandransh 13411 
  def __repr__(self):
13412 
    L = ['%s=%r' % (key, value)
13413 
      for key, value in self.__dict__.iteritems()]
13414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13415 
 
13416 
  def __eq__(self, other):
13417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13418 
 
13419 
  def __ne__(self, other):
13420 
    return not (self == other)
13421 
 
13422 
class reshipOrder_result:
13423 
  """
13424 
  Attributes:
13425 
   - success
13426 
   - ex
13427 
  """
13428 
 
13429 
  thrift_spec = (
13430 
    (0, TType.I64, 'success', None, None, ), # 0
13431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13432 
  )
13433 
 
13434 
  def __init__(self, success=None, ex=None,):
13435 
    self.success = success
13436 
    self.ex = ex
13437 
 
13438 
  def read(self, iprot):
13439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13441 
      return
13442 
    iprot.readStructBegin()
13443 
    while True:
13444 
      (fname, ftype, fid) = iprot.readFieldBegin()
13445 
      if ftype == TType.STOP:
13446 
        break
13447 
      if fid == 0:
13448 
        if ftype == TType.I64:
13449 
          self.success = iprot.readI64();
13450 
        else:
13451 
          iprot.skip(ftype)
13452 
      elif fid == 1:
13453 
        if ftype == TType.STRUCT:
13454 
          self.ex = TransactionServiceException()
13455 
          self.ex.read(iprot)
13456 
        else:
13457 
          iprot.skip(ftype)
13458 
      else:
13459 
        iprot.skip(ftype)
13460 
      iprot.readFieldEnd()
13461 
    iprot.readStructEnd()
13462 
 
13463 
  def write(self, oprot):
13464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13466 
      return
13467 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13468 
    if self.success is not None:
2616 chandransh 13469 
      oprot.writeFieldBegin('success', TType.I64, 0)
13470 
      oprot.writeI64(self.success)
13471 
      oprot.writeFieldEnd()
3431 rajveer 13472 
    if self.ex is not None:
2616 chandransh 13473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13474 
      self.ex.write(oprot)
13475 
      oprot.writeFieldEnd()
13476 
    oprot.writeFieldStop()
13477 
    oprot.writeStructEnd()
13478 
 
3431 rajveer 13479 
  def validate(self):
13480 
    return
13481 
 
13482 
 
2616 chandransh 13483 
  def __repr__(self):
13484 
    L = ['%s=%r' % (key, value)
13485 
      for key, value in self.__dict__.iteritems()]
13486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13487 
 
13488 
  def __eq__(self, other):
13489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13490 
 
13491 
  def __ne__(self, other):
13492 
    return not (self == other)
13493 
 
13494 
class refundOrder_args:
13495 
  """
13496 
  Attributes:
13497 
   - orderId
3226 chandransh 13498 
   - refundedBy
13499 
   - reason
2616 chandransh 13500 
  """
13501 
 
13502 
  thrift_spec = (
13503 
    None, # 0
13504 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13505 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13506 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13507 
  )
13508 
 
3226 chandransh 13509 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13510 
    self.orderId = orderId
3226 chandransh 13511 
    self.refundedBy = refundedBy
13512 
    self.reason = reason
2616 chandransh 13513 
 
13514 
  def read(self, iprot):
13515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13517 
      return
13518 
    iprot.readStructBegin()
13519 
    while True:
13520 
      (fname, ftype, fid) = iprot.readFieldBegin()
13521 
      if ftype == TType.STOP:
13522 
        break
13523 
      if fid == 1:
13524 
        if ftype == TType.I64:
13525 
          self.orderId = iprot.readI64();
13526 
        else:
13527 
          iprot.skip(ftype)
3226 chandransh 13528 
      elif fid == 2:
13529 
        if ftype == TType.STRING:
13530 
          self.refundedBy = iprot.readString();
13531 
        else:
13532 
          iprot.skip(ftype)
13533 
      elif fid == 3:
13534 
        if ftype == TType.STRING:
13535 
          self.reason = iprot.readString();
13536 
        else:
13537 
          iprot.skip(ftype)
2616 chandransh 13538 
      else:
13539 
        iprot.skip(ftype)
13540 
      iprot.readFieldEnd()
13541 
    iprot.readStructEnd()
13542 
 
13543 
  def write(self, oprot):
13544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13546 
      return
13547 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13548 
    if self.orderId is not None:
2616 chandransh 13549 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13550 
      oprot.writeI64(self.orderId)
13551 
      oprot.writeFieldEnd()
3431 rajveer 13552 
    if self.refundedBy is not None:
3226 chandransh 13553 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13554 
      oprot.writeString(self.refundedBy)
13555 
      oprot.writeFieldEnd()
3431 rajveer 13556 
    if self.reason is not None:
3226 chandransh 13557 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13558 
      oprot.writeString(self.reason)
13559 
      oprot.writeFieldEnd()
2616 chandransh 13560 
    oprot.writeFieldStop()
13561 
    oprot.writeStructEnd()
13562 
 
3431 rajveer 13563 
  def validate(self):
13564 
    return
13565 
 
13566 
 
2616 chandransh 13567 
  def __repr__(self):
13568 
    L = ['%s=%r' % (key, value)
13569 
      for key, value in self.__dict__.iteritems()]
13570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13571 
 
13572 
  def __eq__(self, other):
13573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13574 
 
13575 
  def __ne__(self, other):
13576 
    return not (self == other)
13577 
 
13578 
class refundOrder_result:
13579 
  """
13580 
  Attributes:
13581 
   - success
13582 
   - ex
13583 
  """
13584 
 
13585 
  thrift_spec = (
13586 
    (0, TType.BOOL, 'success', None, None, ), # 0
13587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13588 
  )
13589 
 
13590 
  def __init__(self, success=None, ex=None,):
13591 
    self.success = success
13592 
    self.ex = ex
13593 
 
13594 
  def read(self, iprot):
13595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13597 
      return
13598 
    iprot.readStructBegin()
13599 
    while True:
13600 
      (fname, ftype, fid) = iprot.readFieldBegin()
13601 
      if ftype == TType.STOP:
13602 
        break
13603 
      if fid == 0:
13604 
        if ftype == TType.BOOL:
13605 
          self.success = iprot.readBool();
13606 
        else:
13607 
          iprot.skip(ftype)
13608 
      elif fid == 1:
13609 
        if ftype == TType.STRUCT:
13610 
          self.ex = TransactionServiceException()
13611 
          self.ex.read(iprot)
13612 
        else:
13613 
          iprot.skip(ftype)
13614 
      else:
13615 
        iprot.skip(ftype)
13616 
      iprot.readFieldEnd()
13617 
    iprot.readStructEnd()
13618 
 
13619 
  def write(self, oprot):
13620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13622 
      return
13623 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13624 
    if self.success is not None:
2616 chandransh 13625 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13626 
      oprot.writeBool(self.success)
13627 
      oprot.writeFieldEnd()
3431 rajveer 13628 
    if self.ex is not None:
2616 chandransh 13629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13630 
      self.ex.write(oprot)
13631 
      oprot.writeFieldEnd()
13632 
    oprot.writeFieldStop()
13633 
    oprot.writeStructEnd()
13634 
 
3431 rajveer 13635 
  def validate(self):
13636 
    return
13637 
 
13638 
 
2616 chandransh 13639 
  def __repr__(self):
13640 
    L = ['%s=%r' % (key, value)
13641 
      for key, value in self.__dict__.iteritems()]
13642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13643 
 
13644 
  def __eq__(self, other):
13645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13646 
 
13647 
  def __ne__(self, other):
13648 
    return not (self == other)
13649 
 
2690 chandransh 13650 
class getReturnOrders_args:
13651 
  """
13652 
  Attributes:
13653 
   - warehouseId
13654 
   - fromDate
13655 
   - toDate
13656 
  """
2616 chandransh 13657 
 
2690 chandransh 13658 
  thrift_spec = (
13659 
    None, # 0
13660 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13661 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13662 
    (3, TType.I64, 'toDate', None, None, ), # 3
13663 
  )
13664 
 
13665 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13666 
    self.warehouseId = warehouseId
13667 
    self.fromDate = fromDate
13668 
    self.toDate = toDate
13669 
 
13670 
  def read(self, iprot):
13671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13673 
      return
13674 
    iprot.readStructBegin()
13675 
    while True:
13676 
      (fname, ftype, fid) = iprot.readFieldBegin()
13677 
      if ftype == TType.STOP:
13678 
        break
13679 
      if fid == 1:
13680 
        if ftype == TType.I64:
13681 
          self.warehouseId = iprot.readI64();
13682 
        else:
13683 
          iprot.skip(ftype)
13684 
      elif fid == 2:
13685 
        if ftype == TType.I64:
13686 
          self.fromDate = iprot.readI64();
13687 
        else:
13688 
          iprot.skip(ftype)
13689 
      elif fid == 3:
13690 
        if ftype == TType.I64:
13691 
          self.toDate = iprot.readI64();
13692 
        else:
13693 
          iprot.skip(ftype)
13694 
      else:
13695 
        iprot.skip(ftype)
13696 
      iprot.readFieldEnd()
13697 
    iprot.readStructEnd()
13698 
 
13699 
  def write(self, oprot):
13700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13702 
      return
13703 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13704 
    if self.warehouseId is not None:
2690 chandransh 13705 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13706 
      oprot.writeI64(self.warehouseId)
13707 
      oprot.writeFieldEnd()
3431 rajveer 13708 
    if self.fromDate is not None:
2690 chandransh 13709 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13710 
      oprot.writeI64(self.fromDate)
13711 
      oprot.writeFieldEnd()
3431 rajveer 13712 
    if self.toDate is not None:
2690 chandransh 13713 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13714 
      oprot.writeI64(self.toDate)
13715 
      oprot.writeFieldEnd()
13716 
    oprot.writeFieldStop()
13717 
    oprot.writeStructEnd()
13718 
 
3431 rajveer 13719 
  def validate(self):
13720 
    return
13721 
 
13722 
 
2690 chandransh 13723 
  def __repr__(self):
13724 
    L = ['%s=%r' % (key, value)
13725 
      for key, value in self.__dict__.iteritems()]
13726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13727 
 
13728 
  def __eq__(self, other):
13729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13730 
 
13731 
  def __ne__(self, other):
13732 
    return not (self == other)
13733 
 
13734 
class getReturnOrders_result:
13735 
  """
13736 
  Attributes:
13737 
   - success
13738 
  """
13739 
 
13740 
  thrift_spec = (
13741 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13742 
  )
13743 
 
13744 
  def __init__(self, success=None,):
13745 
    self.success = success
13746 
 
13747 
  def read(self, iprot):
13748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13750 
      return
13751 
    iprot.readStructBegin()
13752 
    while True:
13753 
      (fname, ftype, fid) = iprot.readFieldBegin()
13754 
      if ftype == TType.STOP:
13755 
        break
13756 
      if fid == 0:
13757 
        if ftype == TType.LIST:
13758 
          self.success = []
4581 phani.kuma 13759 
          (_etype216, _size213) = iprot.readListBegin()
13760 
          for _i217 in xrange(_size213):
13761 
            _elem218 = ReturnOrder()
13762 
            _elem218.read(iprot)
13763 
            self.success.append(_elem218)
2690 chandransh 13764 
          iprot.readListEnd()
13765 
        else:
13766 
          iprot.skip(ftype)
13767 
      else:
13768 
        iprot.skip(ftype)
13769 
      iprot.readFieldEnd()
13770 
    iprot.readStructEnd()
13771 
 
13772 
  def write(self, oprot):
13773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13775 
      return
13776 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13777 
    if self.success is not None:
2690 chandransh 13778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13780 
      for iter219 in self.success:
13781 
        iter219.write(oprot)
2690 chandransh 13782 
      oprot.writeListEnd()
13783 
      oprot.writeFieldEnd()
13784 
    oprot.writeFieldStop()
13785 
    oprot.writeStructEnd()
13786 
 
3431 rajveer 13787 
  def validate(self):
13788 
    return
13789 
 
13790 
 
2690 chandransh 13791 
  def __repr__(self):
13792 
    L = ['%s=%r' % (key, value)
13793 
      for key, value in self.__dict__.iteritems()]
13794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13795 
 
13796 
  def __eq__(self, other):
13797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13798 
 
13799 
  def __ne__(self, other):
13800 
    return not (self == other)
13801 
 
2700 chandransh 13802 
class getReturnOrder_args:
13803 
  """
13804 
  Attributes:
13805 
   - id
13806 
  """
13807 
 
13808 
  thrift_spec = (
13809 
    None, # 0
13810 
    (1, TType.I64, 'id', None, None, ), # 1
13811 
  )
13812 
 
13813 
  def __init__(self, id=None,):
13814 
    self.id = id
13815 
 
13816 
  def read(self, iprot):
13817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13819 
      return
13820 
    iprot.readStructBegin()
13821 
    while True:
13822 
      (fname, ftype, fid) = iprot.readFieldBegin()
13823 
      if ftype == TType.STOP:
13824 
        break
13825 
      if fid == 1:
13826 
        if ftype == TType.I64:
13827 
          self.id = iprot.readI64();
13828 
        else:
13829 
          iprot.skip(ftype)
13830 
      else:
13831 
        iprot.skip(ftype)
13832 
      iprot.readFieldEnd()
13833 
    iprot.readStructEnd()
13834 
 
13835 
  def write(self, oprot):
13836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13838 
      return
13839 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13840 
    if self.id is not None:
2700 chandransh 13841 
      oprot.writeFieldBegin('id', TType.I64, 1)
13842 
      oprot.writeI64(self.id)
13843 
      oprot.writeFieldEnd()
13844 
    oprot.writeFieldStop()
13845 
    oprot.writeStructEnd()
13846 
 
3431 rajveer 13847 
  def validate(self):
13848 
    return
13849 
 
13850 
 
2700 chandransh 13851 
  def __repr__(self):
13852 
    L = ['%s=%r' % (key, value)
13853 
      for key, value in self.__dict__.iteritems()]
13854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13855 
 
13856 
  def __eq__(self, other):
13857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13858 
 
13859 
  def __ne__(self, other):
13860 
    return not (self == other)
13861 
 
13862 
class getReturnOrder_result:
13863 
  """
13864 
  Attributes:
13865 
   - success
13866 
   - ex
13867 
  """
13868 
 
13869 
  thrift_spec = (
13870 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13872 
  )
13873 
 
13874 
  def __init__(self, success=None, ex=None,):
13875 
    self.success = success
13876 
    self.ex = ex
13877 
 
13878 
  def read(self, iprot):
13879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13881 
      return
13882 
    iprot.readStructBegin()
13883 
    while True:
13884 
      (fname, ftype, fid) = iprot.readFieldBegin()
13885 
      if ftype == TType.STOP:
13886 
        break
13887 
      if fid == 0:
13888 
        if ftype == TType.STRUCT:
13889 
          self.success = ReturnOrder()
13890 
          self.success.read(iprot)
13891 
        else:
13892 
          iprot.skip(ftype)
13893 
      elif fid == 1:
13894 
        if ftype == TType.STRUCT:
13895 
          self.ex = TransactionServiceException()
13896 
          self.ex.read(iprot)
13897 
        else:
13898 
          iprot.skip(ftype)
13899 
      else:
13900 
        iprot.skip(ftype)
13901 
      iprot.readFieldEnd()
13902 
    iprot.readStructEnd()
13903 
 
13904 
  def write(self, oprot):
13905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13907 
      return
13908 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13909 
    if self.success is not None:
2700 chandransh 13910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13911 
      self.success.write(oprot)
13912 
      oprot.writeFieldEnd()
3431 rajveer 13913 
    if self.ex is not None:
2700 chandransh 13914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13915 
      self.ex.write(oprot)
13916 
      oprot.writeFieldEnd()
13917 
    oprot.writeFieldStop()
13918 
    oprot.writeStructEnd()
13919 
 
3431 rajveer 13920 
  def validate(self):
13921 
    return
13922 
 
13923 
 
2700 chandransh 13924 
  def __repr__(self):
13925 
    L = ['%s=%r' % (key, value)
13926 
      for key, value in self.__dict__.iteritems()]
13927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13928 
 
13929 
  def __eq__(self, other):
13930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13931 
 
13932 
  def __ne__(self, other):
13933 
    return not (self == other)
13934 
 
2690 chandransh 13935 
class processReturn_args:
13936 
  """
13937 
  Attributes:
13938 
   - returnOrderId
13939 
  """
13940 
 
13941 
  thrift_spec = (
13942 
    None, # 0
13943 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13944 
  )
13945 
 
13946 
  def __init__(self, returnOrderId=None,):
13947 
    self.returnOrderId = returnOrderId
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 1:
13959 
        if ftype == TType.I64:
13960 
          self.returnOrderId = iprot.readI64();
13961 
        else:
13962 
          iprot.skip(ftype)
13963 
      else:
13964 
        iprot.skip(ftype)
13965 
      iprot.readFieldEnd()
13966 
    iprot.readStructEnd()
13967 
 
13968 
  def write(self, oprot):
13969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13971 
      return
13972 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13973 
    if self.returnOrderId is not None:
2690 chandransh 13974 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13975 
      oprot.writeI64(self.returnOrderId)
13976 
      oprot.writeFieldEnd()
13977 
    oprot.writeFieldStop()
13978 
    oprot.writeStructEnd()
13979 
 
3431 rajveer 13980 
  def validate(self):
13981 
    return
13982 
 
13983 
 
2690 chandransh 13984 
  def __repr__(self):
13985 
    L = ['%s=%r' % (key, value)
13986 
      for key, value in self.__dict__.iteritems()]
13987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13988 
 
13989 
  def __eq__(self, other):
13990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13991 
 
13992 
  def __ne__(self, other):
13993 
    return not (self == other)
13994 
 
13995 
class processReturn_result:
13996 
  """
13997 
  Attributes:
13998 
   - ex
13999 
  """
14000 
 
14001 
  thrift_spec = (
14002 
    None, # 0
14003 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14004 
  )
14005 
 
14006 
  def __init__(self, ex=None,):
14007 
    self.ex = ex
14008 
 
14009 
  def read(self, iprot):
14010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14012 
      return
14013 
    iprot.readStructBegin()
14014 
    while True:
14015 
      (fname, ftype, fid) = iprot.readFieldBegin()
14016 
      if ftype == TType.STOP:
14017 
        break
14018 
      if fid == 1:
14019 
        if ftype == TType.STRUCT:
14020 
          self.ex = TransactionServiceException()
14021 
          self.ex.read(iprot)
14022 
        else:
14023 
          iprot.skip(ftype)
14024 
      else:
14025 
        iprot.skip(ftype)
14026 
      iprot.readFieldEnd()
14027 
    iprot.readStructEnd()
14028 
 
14029 
  def write(self, oprot):
14030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14032 
      return
14033 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14034 
    if self.ex is not None:
2690 chandransh 14035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14036 
      self.ex.write(oprot)
14037 
      oprot.writeFieldEnd()
14038 
    oprot.writeFieldStop()
14039 
    oprot.writeStructEnd()
14040 
 
3431 rajveer 14041 
  def validate(self):
14042 
    return
14043 
 
14044 
 
2690 chandransh 14045 
  def __repr__(self):
14046 
    L = ['%s=%r' % (key, value)
14047 
      for key, value in self.__dict__.iteritems()]
14048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14049 
 
14050 
  def __eq__(self, other):
14051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14052 
 
14053 
  def __ne__(self, other):
14054 
    return not (self == other)
14055 
 
2819 chandransh 14056 
class createPurchaseOrder_args:
14057 
  """
14058 
  Attributes:
14059 
   - warehouseId
14060 
  """
2690 chandransh 14061 
 
2819 chandransh 14062 
  thrift_spec = (
14063 
    None, # 0
14064 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14065 
  )
14066 
 
14067 
  def __init__(self, warehouseId=None,):
14068 
    self.warehouseId = warehouseId
14069 
 
14070 
  def read(self, iprot):
14071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14073 
      return
14074 
    iprot.readStructBegin()
14075 
    while True:
14076 
      (fname, ftype, fid) = iprot.readFieldBegin()
14077 
      if ftype == TType.STOP:
14078 
        break
14079 
      if fid == 1:
14080 
        if ftype == TType.I64:
14081 
          self.warehouseId = iprot.readI64();
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      else:
14085 
        iprot.skip(ftype)
14086 
      iprot.readFieldEnd()
14087 
    iprot.readStructEnd()
14088 
 
14089 
  def write(self, oprot):
14090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14092 
      return
14093 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 14094 
    if self.warehouseId is not None:
2819 chandransh 14095 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14096 
      oprot.writeI64(self.warehouseId)
14097 
      oprot.writeFieldEnd()
14098 
    oprot.writeFieldStop()
14099 
    oprot.writeStructEnd()
14100 
 
3431 rajveer 14101 
  def validate(self):
14102 
    return
14103 
 
14104 
 
2819 chandransh 14105 
  def __repr__(self):
14106 
    L = ['%s=%r' % (key, value)
14107 
      for key, value in self.__dict__.iteritems()]
14108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14109 
 
14110 
  def __eq__(self, other):
14111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14112 
 
14113 
  def __ne__(self, other):
14114 
    return not (self == other)
14115 
 
14116 
class createPurchaseOrder_result:
14117 
  """
14118 
  Attributes:
14119 
   - success
14120 
   - ex
14121 
  """
14122 
 
14123 
  thrift_spec = (
4586 mandeep.dh 14124 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 14125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14126 
  )
14127 
 
14128 
  def __init__(self, success=None, ex=None,):
14129 
    self.success = success
14130 
    self.ex = ex
14131 
 
14132 
  def read(self, iprot):
14133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14135 
      return
14136 
    iprot.readStructBegin()
14137 
    while True:
14138 
      (fname, ftype, fid) = iprot.readFieldBegin()
14139 
      if ftype == TType.STOP:
14140 
        break
14141 
      if fid == 0:
4586 mandeep.dh 14142 
        if ftype == TType.LIST:
14143 
          self.success = []
14144 
          (_etype223, _size220) = iprot.readListBegin()
14145 
          for _i224 in xrange(_size220):
14146 
            _elem225 = iprot.readI64();
14147 
            self.success.append(_elem225)
14148 
          iprot.readListEnd()
2819 chandransh 14149 
        else:
14150 
          iprot.skip(ftype)
14151 
      elif fid == 1:
14152 
        if ftype == TType.STRUCT:
14153 
          self.ex = TransactionServiceException()
14154 
          self.ex.read(iprot)
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      else:
14158 
        iprot.skip(ftype)
14159 
      iprot.readFieldEnd()
14160 
    iprot.readStructEnd()
14161 
 
14162 
  def write(self, oprot):
14163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14165 
      return
14166 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 14167 
    if self.success is not None:
4586 mandeep.dh 14168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14169 
      oprot.writeListBegin(TType.I64, len(self.success))
14170 
      for iter226 in self.success:
14171 
        oprot.writeI64(iter226)
14172 
      oprot.writeListEnd()
2819 chandransh 14173 
      oprot.writeFieldEnd()
3431 rajveer 14174 
    if self.ex is not None:
2819 chandransh 14175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14176 
      self.ex.write(oprot)
14177 
      oprot.writeFieldEnd()
14178 
    oprot.writeFieldStop()
14179 
    oprot.writeStructEnd()
14180 
 
3431 rajveer 14181 
  def validate(self):
14182 
    return
14183 
 
14184 
 
2819 chandransh 14185 
  def __repr__(self):
14186 
    L = ['%s=%r' % (key, value)
14187 
      for key, value in self.__dict__.iteritems()]
14188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14189 
 
14190 
  def __eq__(self, other):
14191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14192 
 
14193 
  def __ne__(self, other):
14194 
    return not (self == other)
3451 chandransh 14195 
 
14196 
class updateWeight_args:
14197 
  """
14198 
  Attributes:
14199 
   - orderId
14200 
   - weight
14201 
  """
14202 
 
14203 
  thrift_spec = (
14204 
    None, # 0
14205 
    (1, TType.I64, 'orderId', None, None, ), # 1
14206 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14207 
  )
14208 
 
14209 
  def __init__(self, orderId=None, weight=None,):
14210 
    self.orderId = orderId
14211 
    self.weight = weight
14212 
 
14213 
  def read(self, iprot):
14214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14216 
      return
14217 
    iprot.readStructBegin()
14218 
    while True:
14219 
      (fname, ftype, fid) = iprot.readFieldBegin()
14220 
      if ftype == TType.STOP:
14221 
        break
14222 
      if fid == 1:
14223 
        if ftype == TType.I64:
14224 
          self.orderId = iprot.readI64();
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      elif fid == 2:
14228 
        if ftype == TType.DOUBLE:
14229 
          self.weight = iprot.readDouble();
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
14241 
    oprot.writeStructBegin('updateWeight_args')
14242 
    if self.orderId is not None:
14243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14244 
      oprot.writeI64(self.orderId)
14245 
      oprot.writeFieldEnd()
14246 
    if self.weight is not None:
14247 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14248 
      oprot.writeDouble(self.weight)
14249 
      oprot.writeFieldEnd()
14250 
    oprot.writeFieldStop()
14251 
    oprot.writeStructEnd()
14252 
 
14253 
  def validate(self):
14254 
    return
14255 
 
14256 
 
14257 
  def __repr__(self):
14258 
    L = ['%s=%r' % (key, value)
14259 
      for key, value in self.__dict__.iteritems()]
14260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14261 
 
14262 
  def __eq__(self, other):
14263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14264 
 
14265 
  def __ne__(self, other):
14266 
    return not (self == other)
14267 
 
14268 
class updateWeight_result:
14269 
  """
14270 
  Attributes:
14271 
   - success
14272 
   - ex
14273 
  """
14274 
 
14275 
  thrift_spec = (
14276 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14278 
  )
14279 
 
14280 
  def __init__(self, success=None, ex=None,):
14281 
    self.success = success
14282 
    self.ex = ex
14283 
 
14284 
  def read(self, iprot):
14285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14287 
      return
14288 
    iprot.readStructBegin()
14289 
    while True:
14290 
      (fname, ftype, fid) = iprot.readFieldBegin()
14291 
      if ftype == TType.STOP:
14292 
        break
14293 
      if fid == 0:
14294 
        if ftype == TType.STRUCT:
14295 
          self.success = Order()
14296 
          self.success.read(iprot)
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      elif fid == 1:
14300 
        if ftype == TType.STRUCT:
14301 
          self.ex = TransactionServiceException()
14302 
          self.ex.read(iprot)
14303 
        else:
14304 
          iprot.skip(ftype)
14305 
      else:
14306 
        iprot.skip(ftype)
14307 
      iprot.readFieldEnd()
14308 
    iprot.readStructEnd()
14309 
 
14310 
  def write(self, oprot):
14311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14313 
      return
14314 
    oprot.writeStructBegin('updateWeight_result')
14315 
    if self.success is not None:
14316 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14317 
      self.success.write(oprot)
14318 
      oprot.writeFieldEnd()
14319 
    if self.ex is not None:
14320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14321 
      self.ex.write(oprot)
14322 
      oprot.writeFieldEnd()
14323 
    oprot.writeFieldStop()
14324 
    oprot.writeStructEnd()
14325 
 
14326 
  def validate(self):
14327 
    return
14328 
 
14329 
 
14330 
  def __repr__(self):
14331 
    L = ['%s=%r' % (key, value)
14332 
      for key, value in self.__dict__.iteritems()]
14333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14334 
 
14335 
  def __eq__(self, other):
14336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14337 
 
14338 
  def __ne__(self, other):
14339 
    return not (self == other)
3469 chandransh 14340 
 
14341 
class changeItem_args:
14342 
  """
14343 
  Attributes:
14344 
   - orderId
14345 
   - itemId
14346 
  """
14347 
 
14348 
  thrift_spec = (
14349 
    None, # 0
14350 
    (1, TType.I64, 'orderId', None, None, ), # 1
14351 
    (2, TType.I64, 'itemId', None, None, ), # 2
14352 
  )
14353 
 
14354 
  def __init__(self, orderId=None, itemId=None,):
14355 
    self.orderId = orderId
14356 
    self.itemId = itemId
14357 
 
14358 
  def read(self, iprot):
14359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14361 
      return
14362 
    iprot.readStructBegin()
14363 
    while True:
14364 
      (fname, ftype, fid) = iprot.readFieldBegin()
14365 
      if ftype == TType.STOP:
14366 
        break
14367 
      if fid == 1:
14368 
        if ftype == TType.I64:
14369 
          self.orderId = iprot.readI64();
14370 
        else:
14371 
          iprot.skip(ftype)
14372 
      elif fid == 2:
14373 
        if ftype == TType.I64:
14374 
          self.itemId = iprot.readI64();
14375 
        else:
14376 
          iprot.skip(ftype)
14377 
      else:
14378 
        iprot.skip(ftype)
14379 
      iprot.readFieldEnd()
14380 
    iprot.readStructEnd()
14381 
 
14382 
  def write(self, oprot):
14383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14385 
      return
14386 
    oprot.writeStructBegin('changeItem_args')
14387 
    if self.orderId is not None:
14388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14389 
      oprot.writeI64(self.orderId)
14390 
      oprot.writeFieldEnd()
14391 
    if self.itemId is not None:
14392 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14393 
      oprot.writeI64(self.itemId)
14394 
      oprot.writeFieldEnd()
14395 
    oprot.writeFieldStop()
14396 
    oprot.writeStructEnd()
14397 
 
14398 
  def validate(self):
14399 
    return
14400 
 
14401 
 
14402 
  def __repr__(self):
14403 
    L = ['%s=%r' % (key, value)
14404 
      for key, value in self.__dict__.iteritems()]
14405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14406 
 
14407 
  def __eq__(self, other):
14408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14409 
 
14410 
  def __ne__(self, other):
14411 
    return not (self == other)
14412 
 
14413 
class changeItem_result:
14414 
  """
14415 
  Attributes:
14416 
   - success
14417 
   - ex
14418 
  """
14419 
 
14420 
  thrift_spec = (
14421 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14423 
  )
14424 
 
14425 
  def __init__(self, success=None, ex=None,):
14426 
    self.success = success
14427 
    self.ex = ex
14428 
 
14429 
  def read(self, iprot):
14430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14432 
      return
14433 
    iprot.readStructBegin()
14434 
    while True:
14435 
      (fname, ftype, fid) = iprot.readFieldBegin()
14436 
      if ftype == TType.STOP:
14437 
        break
14438 
      if fid == 0:
14439 
        if ftype == TType.STRUCT:
14440 
          self.success = Order()
14441 
          self.success.read(iprot)
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      elif fid == 1:
14445 
        if ftype == TType.STRUCT:
14446 
          self.ex = TransactionServiceException()
14447 
          self.ex.read(iprot)
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('changeItem_result')
14460 
    if self.success is not None:
14461 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14462 
      self.success.write(oprot)
14463 
      oprot.writeFieldEnd()
14464 
    if self.ex is not None:
14465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14466 
      self.ex.write(oprot)
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 shiftToWarehouse_args:
14487 
  """
14488 
  Attributes:
14489 
   - orderId
14490 
   - warehouseId
14491 
  """
14492 
 
14493 
  thrift_spec = (
14494 
    None, # 0
14495 
    (1, TType.I64, 'orderId', None, None, ), # 1
14496 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14497 
  )
14498 
 
14499 
  def __init__(self, orderId=None, warehouseId=None,):
14500 
    self.orderId = orderId
14501 
    self.warehouseId = warehouseId
14502 
 
14503 
  def read(self, iprot):
14504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14506 
      return
14507 
    iprot.readStructBegin()
14508 
    while True:
14509 
      (fname, ftype, fid) = iprot.readFieldBegin()
14510 
      if ftype == TType.STOP:
14511 
        break
14512 
      if fid == 1:
14513 
        if ftype == TType.I64:
14514 
          self.orderId = iprot.readI64();
14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      elif fid == 2:
14518 
        if ftype == TType.I64:
14519 
          self.warehouseId = iprot.readI64();
14520 
        else:
14521 
          iprot.skip(ftype)
14522 
      else:
14523 
        iprot.skip(ftype)
14524 
      iprot.readFieldEnd()
14525 
    iprot.readStructEnd()
14526 
 
14527 
  def write(self, oprot):
14528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14530 
      return
14531 
    oprot.writeStructBegin('shiftToWarehouse_args')
14532 
    if self.orderId is not None:
14533 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14534 
      oprot.writeI64(self.orderId)
14535 
      oprot.writeFieldEnd()
14536 
    if self.warehouseId is not None:
14537 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14538 
      oprot.writeI64(self.warehouseId)
14539 
      oprot.writeFieldEnd()
14540 
    oprot.writeFieldStop()
14541 
    oprot.writeStructEnd()
14542 
 
14543 
  def validate(self):
14544 
    return
14545 
 
14546 
 
14547 
  def __repr__(self):
14548 
    L = ['%s=%r' % (key, value)
14549 
      for key, value in self.__dict__.iteritems()]
14550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14551 
 
14552 
  def __eq__(self, other):
14553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14554 
 
14555 
  def __ne__(self, other):
14556 
    return not (self == other)
14557 
 
14558 
class shiftToWarehouse_result:
14559 
  """
14560 
  Attributes:
14561 
   - success
14562 
   - ex
14563 
  """
14564 
 
14565 
  thrift_spec = (
14566 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14568 
  )
14569 
 
14570 
  def __init__(self, success=None, ex=None,):
14571 
    self.success = success
14572 
    self.ex = ex
14573 
 
14574 
  def read(self, iprot):
14575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14577 
      return
14578 
    iprot.readStructBegin()
14579 
    while True:
14580 
      (fname, ftype, fid) = iprot.readFieldBegin()
14581 
      if ftype == TType.STOP:
14582 
        break
14583 
      if fid == 0:
14584 
        if ftype == TType.STRUCT:
14585 
          self.success = Order()
14586 
          self.success.read(iprot)
14587 
        else:
14588 
          iprot.skip(ftype)
14589 
      elif fid == 1:
14590 
        if ftype == TType.STRUCT:
14591 
          self.ex = TransactionServiceException()
14592 
          self.ex.read(iprot)
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('shiftToWarehouse_result')
14605 
    if self.success is not None:
14606 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14607 
      self.success.write(oprot)
14608 
      oprot.writeFieldEnd()
14609 
    if self.ex is not None:
14610 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14611 
      self.ex.write(oprot)
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)
3553 chandransh 14630 
 
14631 
class addDelayReason_args:
14632 
  """
14633 
  Attributes:
14634 
   - orderId
14635 
   - delayReason
3986 chandransh 14636 
   - furtherDelay
4647 rajveer 14637 
   - delayReasonText
3553 chandransh 14638 
  """
14639 
 
14640 
  thrift_spec = (
14641 
    None, # 0
14642 
    (1, TType.I64, 'orderId', None, None, ), # 1
14643 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14644 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14645 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14646 
  )
14647 
 
4647 rajveer 14648 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14649 
    self.orderId = orderId
14650 
    self.delayReason = delayReason
3986 chandransh 14651 
    self.furtherDelay = furtherDelay
4647 rajveer 14652 
    self.delayReasonText = delayReasonText
3553 chandransh 14653 
 
14654 
  def read(self, iprot):
14655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14657 
      return
14658 
    iprot.readStructBegin()
14659 
    while True:
14660 
      (fname, ftype, fid) = iprot.readFieldBegin()
14661 
      if ftype == TType.STOP:
14662 
        break
14663 
      if fid == 1:
14664 
        if ftype == TType.I64:
14665 
          self.orderId = iprot.readI64();
14666 
        else:
14667 
          iprot.skip(ftype)
14668 
      elif fid == 2:
14669 
        if ftype == TType.I32:
14670 
          self.delayReason = iprot.readI32();
14671 
        else:
14672 
          iprot.skip(ftype)
3986 chandransh 14673 
      elif fid == 3:
14674 
        if ftype == TType.I64:
14675 
          self.furtherDelay = iprot.readI64();
14676 
        else:
14677 
          iprot.skip(ftype)
4647 rajveer 14678 
      elif fid == 4:
14679 
        if ftype == TType.STRING:
14680 
          self.delayReasonText = iprot.readString();
14681 
        else:
14682 
          iprot.skip(ftype)
3553 chandransh 14683 
      else:
14684 
        iprot.skip(ftype)
14685 
      iprot.readFieldEnd()
14686 
    iprot.readStructEnd()
14687 
 
14688 
  def write(self, oprot):
14689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14691 
      return
14692 
    oprot.writeStructBegin('addDelayReason_args')
14693 
    if self.orderId is not None:
14694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14695 
      oprot.writeI64(self.orderId)
14696 
      oprot.writeFieldEnd()
14697 
    if self.delayReason is not None:
14698 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14699 
      oprot.writeI32(self.delayReason)
14700 
      oprot.writeFieldEnd()
3986 chandransh 14701 
    if self.furtherDelay is not None:
14702 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14703 
      oprot.writeI64(self.furtherDelay)
14704 
      oprot.writeFieldEnd()
4647 rajveer 14705 
    if self.delayReasonText is not None:
14706 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14707 
      oprot.writeString(self.delayReasonText)
14708 
      oprot.writeFieldEnd()
3553 chandransh 14709 
    oprot.writeFieldStop()
14710 
    oprot.writeStructEnd()
14711 
 
14712 
  def validate(self):
14713 
    return
14714 
 
14715 
 
14716 
  def __repr__(self):
14717 
    L = ['%s=%r' % (key, value)
14718 
      for key, value in self.__dict__.iteritems()]
14719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14720 
 
14721 
  def __eq__(self, other):
14722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14723 
 
14724 
  def __ne__(self, other):
14725 
    return not (self == other)
14726 
 
14727 
class addDelayReason_result:
14728 
  """
14729 
  Attributes:
14730 
   - success
14731 
   - ex
14732 
  """
14733 
 
14734 
  thrift_spec = (
14735 
    (0, TType.BOOL, 'success', None, None, ), # 0
14736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14737 
  )
14738 
 
14739 
  def __init__(self, success=None, ex=None,):
14740 
    self.success = success
14741 
    self.ex = ex
14742 
 
14743 
  def read(self, iprot):
14744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14746 
      return
14747 
    iprot.readStructBegin()
14748 
    while True:
14749 
      (fname, ftype, fid) = iprot.readFieldBegin()
14750 
      if ftype == TType.STOP:
14751 
        break
14752 
      if fid == 0:
14753 
        if ftype == TType.BOOL:
14754 
          self.success = iprot.readBool();
14755 
        else:
14756 
          iprot.skip(ftype)
14757 
      elif fid == 1:
14758 
        if ftype == TType.STRUCT:
14759 
          self.ex = TransactionServiceException()
14760 
          self.ex.read(iprot)
14761 
        else:
14762 
          iprot.skip(ftype)
14763 
      else:
14764 
        iprot.skip(ftype)
14765 
      iprot.readFieldEnd()
14766 
    iprot.readStructEnd()
14767 
 
14768 
  def write(self, oprot):
14769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14771 
      return
14772 
    oprot.writeStructBegin('addDelayReason_result')
14773 
    if self.success is not None:
14774 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14775 
      oprot.writeBool(self.success)
14776 
      oprot.writeFieldEnd()
14777 
    if self.ex is not None:
14778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14779 
      self.ex.write(oprot)
14780 
      oprot.writeFieldEnd()
14781 
    oprot.writeFieldStop()
14782 
    oprot.writeStructEnd()
14783 
 
14784 
  def validate(self):
14785 
    return
14786 
 
14787 
 
14788 
  def __repr__(self):
14789 
    L = ['%s=%r' % (key, value)
14790 
      for key, value in self.__dict__.iteritems()]
14791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14792 
 
14793 
  def __eq__(self, other):
14794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14795 
 
14796 
  def __ne__(self, other):
14797 
    return not (self == other)
3956 chandransh 14798 
 
14799 
class reconcileCodCollection_args:
14800 
  """
14801 
  Attributes:
14802 
   - collectedAmountMap
14803 
   - xferBy
14804 
   - xferTxnId
14805 
   - xferDate
14806 
  """
14807 
 
14808 
  thrift_spec = (
14809 
    None, # 0
14810 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14811 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14812 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14813 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14814 
  )
14815 
 
14816 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14817 
    self.collectedAmountMap = collectedAmountMap
14818 
    self.xferBy = xferBy
14819 
    self.xferTxnId = xferTxnId
14820 
    self.xferDate = xferDate
14821 
 
14822 
  def read(self, iprot):
14823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14825 
      return
14826 
    iprot.readStructBegin()
14827 
    while True:
14828 
      (fname, ftype, fid) = iprot.readFieldBegin()
14829 
      if ftype == TType.STOP:
14830 
        break
14831 
      if fid == 1:
14832 
        if ftype == TType.MAP:
14833 
          self.collectedAmountMap = {}
4586 mandeep.dh 14834 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14835 
          for _i231 in xrange(_size227):
14836 
            _key232 = iprot.readString();
14837 
            _val233 = iprot.readDouble();
14838 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14839 
          iprot.readMapEnd()
14840 
        else:
14841 
          iprot.skip(ftype)
14842 
      elif fid == 2:
14843 
        if ftype == TType.STRING:
14844 
          self.xferBy = iprot.readString();
14845 
        else:
14846 
          iprot.skip(ftype)
14847 
      elif fid == 3:
14848 
        if ftype == TType.STRING:
14849 
          self.xferTxnId = iprot.readString();
14850 
        else:
14851 
          iprot.skip(ftype)
14852 
      elif fid == 4:
14853 
        if ftype == TType.I64:
14854 
          self.xferDate = iprot.readI64();
14855 
        else:
14856 
          iprot.skip(ftype)
14857 
      else:
14858 
        iprot.skip(ftype)
14859 
      iprot.readFieldEnd()
14860 
    iprot.readStructEnd()
14861 
 
14862 
  def write(self, oprot):
14863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14865 
      return
14866 
    oprot.writeStructBegin('reconcileCodCollection_args')
14867 
    if self.collectedAmountMap is not None:
14868 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14869 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14870 
      for kiter234,viter235 in self.collectedAmountMap.items():
14871 
        oprot.writeString(kiter234)
14872 
        oprot.writeDouble(viter235)
3956 chandransh 14873 
      oprot.writeMapEnd()
14874 
      oprot.writeFieldEnd()
14875 
    if self.xferBy is not None:
14876 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14877 
      oprot.writeString(self.xferBy)
14878 
      oprot.writeFieldEnd()
14879 
    if self.xferTxnId is not None:
14880 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14881 
      oprot.writeString(self.xferTxnId)
14882 
      oprot.writeFieldEnd()
14883 
    if self.xferDate is not None:
14884 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14885 
      oprot.writeI64(self.xferDate)
14886 
      oprot.writeFieldEnd()
14887 
    oprot.writeFieldStop()
14888 
    oprot.writeStructEnd()
14889 
 
14890 
  def validate(self):
14891 
    return
14892 
 
14893 
 
14894 
  def __repr__(self):
14895 
    L = ['%s=%r' % (key, value)
14896 
      for key, value in self.__dict__.iteritems()]
14897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14898 
 
14899 
  def __eq__(self, other):
14900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14901 
 
14902 
  def __ne__(self, other):
14903 
    return not (self == other)
14904 
 
14905 
class reconcileCodCollection_result:
14906 
  """
14907 
  Attributes:
14908 
   - success
14909 
   - ex
14910 
  """
14911 
 
14912 
  thrift_spec = (
14913 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14915 
  )
14916 
 
14917 
  def __init__(self, success=None, ex=None,):
14918 
    self.success = success
14919 
    self.ex = ex
14920 
 
14921 
  def read(self, iprot):
14922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14924 
      return
14925 
    iprot.readStructBegin()
14926 
    while True:
14927 
      (fname, ftype, fid) = iprot.readFieldBegin()
14928 
      if ftype == TType.STOP:
14929 
        break
14930 
      if fid == 0:
14931 
        if ftype == TType.MAP:
14932 
          self.success = {}
4586 mandeep.dh 14933 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14934 
          for _i240 in xrange(_size236):
14935 
            _key241 = iprot.readString();
14936 
            _val242 = iprot.readString();
14937 
            self.success[_key241] = _val242
3956 chandransh 14938 
          iprot.readMapEnd()
14939 
        else:
14940 
          iprot.skip(ftype)
14941 
      elif fid == 1:
14942 
        if ftype == TType.STRUCT:
14943 
          self.ex = TransactionServiceException()
14944 
          self.ex.read(iprot)
14945 
        else:
14946 
          iprot.skip(ftype)
14947 
      else:
14948 
        iprot.skip(ftype)
14949 
      iprot.readFieldEnd()
14950 
    iprot.readStructEnd()
14951 
 
14952 
  def write(self, oprot):
14953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14955 
      return
14956 
    oprot.writeStructBegin('reconcileCodCollection_result')
14957 
    if self.success is not None:
14958 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14959 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14960 
      for kiter243,viter244 in self.success.items():
14961 
        oprot.writeString(kiter243)
14962 
        oprot.writeString(viter244)
3956 chandransh 14963 
      oprot.writeMapEnd()
14964 
      oprot.writeFieldEnd()
14965 
    if self.ex is not None:
14966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14967 
      self.ex.write(oprot)
14968 
      oprot.writeFieldEnd()
14969 
    oprot.writeFieldStop()
14970 
    oprot.writeStructEnd()
14971 
 
14972 
  def validate(self):
14973 
    return
14974 
 
14975 
 
14976 
  def __repr__(self):
14977 
    L = ['%s=%r' % (key, value)
14978 
      for key, value in self.__dict__.iteritems()]
14979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14980 
 
14981 
  def __eq__(self, other):
14982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14983 
 
14984 
  def __ne__(self, other):
14985 
    return not (self == other)
4008 mandeep.dh 14986 
 
14987 
class getTransactionsRequiringExtraProcessing_args:
14988 
  """
14989 
  Attributes:
14990 
   - category
14991 
  """
14992 
 
14993 
  thrift_spec = (
14994 
    None, # 0
14995 
    (1, TType.I32, 'category', None, None, ), # 1
14996 
  )
14997 
 
14998 
  def __init__(self, category=None,):
14999 
    self.category = category
15000 
 
15001 
  def read(self, iprot):
15002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15004 
      return
15005 
    iprot.readStructBegin()
15006 
    while True:
15007 
      (fname, ftype, fid) = iprot.readFieldBegin()
15008 
      if ftype == TType.STOP:
15009 
        break
15010 
      if fid == 1:
15011 
        if ftype == TType.I32:
15012 
          self.category = iprot.readI32();
15013 
        else:
15014 
          iprot.skip(ftype)
15015 
      else:
15016 
        iprot.skip(ftype)
15017 
      iprot.readFieldEnd()
15018 
    iprot.readStructEnd()
15019 
 
15020 
  def write(self, oprot):
15021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15023 
      return
15024 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15025 
    if self.category is not None:
15026 
      oprot.writeFieldBegin('category', TType.I32, 1)
15027 
      oprot.writeI32(self.category)
15028 
      oprot.writeFieldEnd()
15029 
    oprot.writeFieldStop()
15030 
    oprot.writeStructEnd()
15031 
 
15032 
  def validate(self):
15033 
    return
15034 
 
15035 
 
15036 
  def __repr__(self):
15037 
    L = ['%s=%r' % (key, value)
15038 
      for key, value in self.__dict__.iteritems()]
15039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15040 
 
15041 
  def __eq__(self, other):
15042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15043 
 
15044 
  def __ne__(self, other):
15045 
    return not (self == other)
15046 
 
15047 
class getTransactionsRequiringExtraProcessing_result:
15048 
  """
15049 
  Attributes:
15050 
   - success
15051 
  """
15052 
 
15053 
  thrift_spec = (
15054 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15055 
  )
15056 
 
15057 
  def __init__(self, success=None,):
15058 
    self.success = success
15059 
 
15060 
  def read(self, iprot):
15061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15063 
      return
15064 
    iprot.readStructBegin()
15065 
    while True:
15066 
      (fname, ftype, fid) = iprot.readFieldBegin()
15067 
      if ftype == TType.STOP:
15068 
        break
15069 
      if fid == 0:
15070 
        if ftype == TType.LIST:
15071 
          self.success = []
4586 mandeep.dh 15072 
          (_etype248, _size245) = iprot.readListBegin()
15073 
          for _i249 in xrange(_size245):
15074 
            _elem250 = iprot.readI64();
15075 
            self.success.append(_elem250)
4008 mandeep.dh 15076 
          iprot.readListEnd()
15077 
        else:
15078 
          iprot.skip(ftype)
15079 
      else:
15080 
        iprot.skip(ftype)
15081 
      iprot.readFieldEnd()
15082 
    iprot.readStructEnd()
15083 
 
15084 
  def write(self, oprot):
15085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15087 
      return
15088 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15089 
    if self.success is not None:
15090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15091 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 15092 
      for iter251 in self.success:
15093 
        oprot.writeI64(iter251)
4008 mandeep.dh 15094 
      oprot.writeListEnd()
15095 
      oprot.writeFieldEnd()
15096 
    oprot.writeFieldStop()
15097 
    oprot.writeStructEnd()
15098 
 
15099 
  def validate(self):
15100 
    return
15101 
 
15102 
 
15103 
  def __repr__(self):
15104 
    L = ['%s=%r' % (key, value)
15105 
      for key, value in self.__dict__.iteritems()]
15106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15107 
 
15108 
  def __eq__(self, other):
15109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15110 
 
15111 
  def __ne__(self, other):
15112 
    return not (self == other)
15113 
 
15114 
class markTransactionAsProcessed_args:
15115 
  """
15116 
  Attributes:
15117 
   - transactionId
15118 
   - category
15119 
  """
15120 
 
15121 
  thrift_spec = (
15122 
    None, # 0
15123 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15124 
    (2, TType.I32, 'category', None, None, ), # 2
15125 
  )
15126 
 
15127 
  def __init__(self, transactionId=None, category=None,):
15128 
    self.transactionId = transactionId
15129 
    self.category = category
15130 
 
15131 
  def read(self, iprot):
15132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15134 
      return
15135 
    iprot.readStructBegin()
15136 
    while True:
15137 
      (fname, ftype, fid) = iprot.readFieldBegin()
15138 
      if ftype == TType.STOP:
15139 
        break
15140 
      if fid == 1:
15141 
        if ftype == TType.I64:
15142 
          self.transactionId = iprot.readI64();
15143 
        else:
15144 
          iprot.skip(ftype)
15145 
      elif fid == 2:
15146 
        if ftype == TType.I32:
15147 
          self.category = iprot.readI32();
15148 
        else:
15149 
          iprot.skip(ftype)
15150 
      else:
15151 
        iprot.skip(ftype)
15152 
      iprot.readFieldEnd()
15153 
    iprot.readStructEnd()
15154 
 
15155 
  def write(self, oprot):
15156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15158 
      return
15159 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15160 
    if self.transactionId is not None:
15161 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15162 
      oprot.writeI64(self.transactionId)
15163 
      oprot.writeFieldEnd()
15164 
    if self.category is not None:
15165 
      oprot.writeFieldBegin('category', TType.I32, 2)
15166 
      oprot.writeI32(self.category)
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
15185 
 
15186 
class markTransactionAsProcessed_result:
15187 
 
15188 
  thrift_spec = (
15189 
  )
15190 
 
15191 
  def read(self, iprot):
15192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15194 
      return
15195 
    iprot.readStructBegin()
15196 
    while True:
15197 
      (fname, ftype, fid) = iprot.readFieldBegin()
15198 
      if ftype == TType.STOP:
15199 
        break
15200 
      else:
15201 
        iprot.skip(ftype)
15202 
      iprot.readFieldEnd()
15203 
    iprot.readStructEnd()
15204 
 
15205 
  def write(self, oprot):
15206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15208 
      return
15209 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15210 
    oprot.writeFieldStop()
15211 
    oprot.writeStructEnd()
15212 
 
15213 
  def validate(self):
15214 
    return
15215 
 
15216 
 
15217 
  def __repr__(self):
15218 
    L = ['%s=%r' % (key, value)
15219 
      for key, value in self.__dict__.iteritems()]
15220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15221 
 
15222 
  def __eq__(self, other):
15223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15224 
 
15225 
  def __ne__(self, other):
15226 
    return not (self == other)
4018 chandransh 15227 
 
15228 
class getItemWiseRiskyOrdersCount_args:
15229 
 
15230 
  thrift_spec = (
15231 
  )
15232 
 
15233 
  def read(self, iprot):
15234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15236 
      return
15237 
    iprot.readStructBegin()
15238 
    while True:
15239 
      (fname, ftype, fid) = iprot.readFieldBegin()
15240 
      if ftype == TType.STOP:
15241 
        break
15242 
      else:
15243 
        iprot.skip(ftype)
15244 
      iprot.readFieldEnd()
15245 
    iprot.readStructEnd()
15246 
 
15247 
  def write(self, oprot):
15248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15250 
      return
15251 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15252 
    oprot.writeFieldStop()
15253 
    oprot.writeStructEnd()
15254 
 
15255 
  def validate(self):
15256 
    return
15257 
 
15258 
 
15259 
  def __repr__(self):
15260 
    L = ['%s=%r' % (key, value)
15261 
      for key, value in self.__dict__.iteritems()]
15262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15263 
 
15264 
  def __eq__(self, other):
15265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15266 
 
15267 
  def __ne__(self, other):
15268 
    return not (self == other)
15269 
 
15270 
class getItemWiseRiskyOrdersCount_result:
15271 
  """
15272 
  Attributes:
15273 
   - success
15274 
  """
15275 
 
15276 
  thrift_spec = (
15277 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15278 
  )
15279 
 
15280 
  def __init__(self, success=None,):
15281 
    self.success = success
15282 
 
15283 
  def read(self, iprot):
15284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15286 
      return
15287 
    iprot.readStructBegin()
15288 
    while True:
15289 
      (fname, ftype, fid) = iprot.readFieldBegin()
15290 
      if ftype == TType.STOP:
15291 
        break
15292 
      if fid == 0:
15293 
        if ftype == TType.MAP:
15294 
          self.success = {}
4586 mandeep.dh 15295 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15296 
          for _i256 in xrange(_size252):
15297 
            _key257 = iprot.readI64();
15298 
            _val258 = iprot.readI64();
15299 
            self.success[_key257] = _val258
4018 chandransh 15300 
          iprot.readMapEnd()
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      else:
15304 
        iprot.skip(ftype)
15305 
      iprot.readFieldEnd()
15306 
    iprot.readStructEnd()
15307 
 
15308 
  def write(self, oprot):
15309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15311 
      return
15312 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15313 
    if self.success is not None:
15314 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15315 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 15316 
      for kiter259,viter260 in self.success.items():
15317 
        oprot.writeI64(kiter259)
15318 
        oprot.writeI64(viter260)
4018 chandransh 15319 
      oprot.writeMapEnd()
15320 
      oprot.writeFieldEnd()
15321 
    oprot.writeFieldStop()
15322 
    oprot.writeStructEnd()
15323 
 
15324 
  def validate(self):
15325 
    return
15326 
 
15327 
 
15328 
  def __repr__(self):
15329 
    L = ['%s=%r' % (key, value)
15330 
      for key, value in self.__dict__.iteritems()]
15331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15332 
 
15333 
  def __eq__(self, other):
15334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15335 
 
15336 
  def __ne__(self, other):
15337 
    return not (self == other)
4247 rajveer 15338 
 
4295 varun.gupt 15339 
class getOrdersForItemIds_args:
15340 
  """
15341 
  Attributes:
15342 
   - itemIds
15343 
  """
15344 
 
15345 
  thrift_spec = (
15346 
    None, # 0
15347 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15348 
  )
15349 
 
15350 
  def __init__(self, itemIds=None,):
15351 
    self.itemIds = itemIds
15352 
 
15353 
  def read(self, iprot):
15354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15356 
      return
15357 
    iprot.readStructBegin()
15358 
    while True:
15359 
      (fname, ftype, fid) = iprot.readFieldBegin()
15360 
      if ftype == TType.STOP:
15361 
        break
15362 
      if fid == 1:
15363 
        if ftype == TType.LIST:
15364 
          self.itemIds = []
4586 mandeep.dh 15365 
          (_etype264, _size261) = iprot.readListBegin()
15366 
          for _i265 in xrange(_size261):
15367 
            _elem266 = iprot.readI64();
15368 
            self.itemIds.append(_elem266)
4295 varun.gupt 15369 
          iprot.readListEnd()
15370 
        else:
15371 
          iprot.skip(ftype)
15372 
      else:
15373 
        iprot.skip(ftype)
15374 
      iprot.readFieldEnd()
15375 
    iprot.readStructEnd()
15376 
 
15377 
  def write(self, oprot):
15378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15380 
      return
15381 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15382 
    if self.itemIds is not None:
15383 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15384 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15385 
      for iter267 in self.itemIds:
15386 
        oprot.writeI64(iter267)
4295 varun.gupt 15387 
      oprot.writeListEnd()
15388 
      oprot.writeFieldEnd()
15389 
    oprot.writeFieldStop()
15390 
    oprot.writeStructEnd()
15391 
 
15392 
  def validate(self):
15393 
    return
15394 
 
15395 
 
15396 
  def __repr__(self):
15397 
    L = ['%s=%r' % (key, value)
15398 
      for key, value in self.__dict__.iteritems()]
15399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15400 
 
15401 
  def __eq__(self, other):
15402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15403 
 
15404 
  def __ne__(self, other):
15405 
    return not (self == other)
15406 
 
15407 
class getOrdersForItemIds_result:
15408 
  """
15409 
  Attributes:
15410 
   - success
15411 
  """
15412 
 
15413 
  thrift_spec = (
15414 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15415 
  )
15416 
 
15417 
  def __init__(self, success=None,):
15418 
    self.success = success
15419 
 
15420 
  def read(self, iprot):
15421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15423 
      return
15424 
    iprot.readStructBegin()
15425 
    while True:
15426 
      (fname, ftype, fid) = iprot.readFieldBegin()
15427 
      if ftype == TType.STOP:
15428 
        break
15429 
      if fid == 0:
15430 
        if ftype == TType.LIST:
15431 
          self.success = []
4586 mandeep.dh 15432 
          (_etype271, _size268) = iprot.readListBegin()
15433 
          for _i272 in xrange(_size268):
15434 
            _elem273 = Order()
15435 
            _elem273.read(iprot)
15436 
            self.success.append(_elem273)
4295 varun.gupt 15437 
          iprot.readListEnd()
15438 
        else:
15439 
          iprot.skip(ftype)
15440 
      else:
15441 
        iprot.skip(ftype)
15442 
      iprot.readFieldEnd()
15443 
    iprot.readStructEnd()
15444 
 
15445 
  def write(self, oprot):
15446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15448 
      return
15449 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15450 
    if self.success is not None:
15451 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15452 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15453 
      for iter274 in self.success:
15454 
        iter274.write(oprot)
4295 varun.gupt 15455 
      oprot.writeListEnd()
15456 
      oprot.writeFieldEnd()
15457 
    oprot.writeFieldStop()
15458 
    oprot.writeStructEnd()
15459 
 
15460 
  def validate(self):
15461 
    return
15462 
 
15463 
 
15464 
  def __repr__(self):
15465 
    L = ['%s=%r' % (key, value)
15466 
      for key, value in self.__dict__.iteritems()]
15467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15468 
 
15469 
  def __eq__(self, other):
15470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15471 
 
15472 
  def __ne__(self, other):
15473 
    return not (self == other)
15474 
 
4247 rajveer 15475 
class markOrderCancellationRequestReceived_args:
15476 
  """
15477 
  Attributes:
15478 
   - orderId
15479 
  """
15480 
 
15481 
  thrift_spec = (
15482 
    None, # 0
15483 
    (1, TType.I64, 'orderId', None, None, ), # 1
15484 
  )
15485 
 
15486 
  def __init__(self, orderId=None,):
15487 
    self.orderId = orderId
15488 
 
15489 
  def read(self, iprot):
15490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15492 
      return
15493 
    iprot.readStructBegin()
15494 
    while True:
15495 
      (fname, ftype, fid) = iprot.readFieldBegin()
15496 
      if ftype == TType.STOP:
15497 
        break
15498 
      if fid == 1:
15499 
        if ftype == TType.I64:
15500 
          self.orderId = iprot.readI64();
15501 
        else:
15502 
          iprot.skip(ftype)
15503 
      else:
15504 
        iprot.skip(ftype)
15505 
      iprot.readFieldEnd()
15506 
    iprot.readStructEnd()
15507 
 
15508 
  def write(self, oprot):
15509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15511 
      return
15512 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15513 
    if self.orderId is not None:
15514 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15515 
      oprot.writeI64(self.orderId)
15516 
      oprot.writeFieldEnd()
15517 
    oprot.writeFieldStop()
15518 
    oprot.writeStructEnd()
15519 
 
15520 
  def validate(self):
15521 
    return
15522 
 
15523 
 
15524 
  def __repr__(self):
15525 
    L = ['%s=%r' % (key, value)
15526 
      for key, value in self.__dict__.iteritems()]
15527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15528 
 
15529 
  def __eq__(self, other):
15530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15531 
 
15532 
  def __ne__(self, other):
15533 
    return not (self == other)
15534 
 
15535 
class markOrderCancellationRequestReceived_result:
15536 
  """
15537 
  Attributes:
15538 
   - ex
15539 
  """
15540 
 
15541 
  thrift_spec = (
15542 
    None, # 0
15543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15544 
  )
15545 
 
15546 
  def __init__(self, ex=None,):
15547 
    self.ex = ex
15548 
 
15549 
  def read(self, iprot):
15550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15552 
      return
15553 
    iprot.readStructBegin()
15554 
    while True:
15555 
      (fname, ftype, fid) = iprot.readFieldBegin()
15556 
      if ftype == TType.STOP:
15557 
        break
15558 
      if fid == 1:
15559 
        if ftype == TType.STRUCT:
15560 
          self.ex = TransactionServiceException()
15561 
          self.ex.read(iprot)
15562 
        else:
15563 
          iprot.skip(ftype)
15564 
      else:
15565 
        iprot.skip(ftype)
15566 
      iprot.readFieldEnd()
15567 
    iprot.readStructEnd()
15568 
 
15569 
  def write(self, oprot):
15570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15572 
      return
15573 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15574 
    if self.ex is not None:
15575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15576 
      self.ex.write(oprot)
15577 
      oprot.writeFieldEnd()
15578 
    oprot.writeFieldStop()
15579 
    oprot.writeStructEnd()
15580 
 
15581 
  def validate(self):
15582 
    return
15583 
 
15584 
 
15585 
  def __repr__(self):
15586 
    L = ['%s=%r' % (key, value)
15587 
      for key, value in self.__dict__.iteritems()]
15588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15589 
 
15590 
  def __eq__(self, other):
15591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15592 
 
15593 
  def __ne__(self, other):
15594 
    return not (self == other)
15595 
 
15596 
class markOrderCancellationRequestConfirmed_args:
15597 
  """
15598 
  Attributes:
15599 
   - orderId
15600 
  """
15601 
 
15602 
  thrift_spec = (
15603 
    None, # 0
15604 
    (1, TType.I64, 'orderId', None, None, ), # 1
15605 
  )
15606 
 
15607 
  def __init__(self, orderId=None,):
15608 
    self.orderId = orderId
15609 
 
15610 
  def read(self, iprot):
15611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15613 
      return
15614 
    iprot.readStructBegin()
15615 
    while True:
15616 
      (fname, ftype, fid) = iprot.readFieldBegin()
15617 
      if ftype == TType.STOP:
15618 
        break
15619 
      if fid == 1:
15620 
        if ftype == TType.I64:
15621 
          self.orderId = iprot.readI64();
15622 
        else:
15623 
          iprot.skip(ftype)
15624 
      else:
15625 
        iprot.skip(ftype)
15626 
      iprot.readFieldEnd()
15627 
    iprot.readStructEnd()
15628 
 
15629 
  def write(self, oprot):
15630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15632 
      return
15633 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15634 
    if self.orderId is not None:
15635 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15636 
      oprot.writeI64(self.orderId)
15637 
      oprot.writeFieldEnd()
15638 
    oprot.writeFieldStop()
15639 
    oprot.writeStructEnd()
15640 
 
15641 
  def validate(self):
15642 
    return
15643 
 
15644 
 
15645 
  def __repr__(self):
15646 
    L = ['%s=%r' % (key, value)
15647 
      for key, value in self.__dict__.iteritems()]
15648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15649 
 
15650 
  def __eq__(self, other):
15651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15652 
 
15653 
  def __ne__(self, other):
15654 
    return not (self == other)
15655 
 
15656 
class markOrderCancellationRequestConfirmed_result:
15657 
  """
15658 
  Attributes:
15659 
   - ex
15660 
  """
15661 
 
15662 
  thrift_spec = (
15663 
    None, # 0
15664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15665 
  )
15666 
 
15667 
  def __init__(self, ex=None,):
15668 
    self.ex = ex
15669 
 
15670 
  def read(self, iprot):
15671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15673 
      return
15674 
    iprot.readStructBegin()
15675 
    while True:
15676 
      (fname, ftype, fid) = iprot.readFieldBegin()
15677 
      if ftype == TType.STOP:
15678 
        break
15679 
      if fid == 1:
15680 
        if ftype == TType.STRUCT:
15681 
          self.ex = TransactionServiceException()
15682 
          self.ex.read(iprot)
15683 
        else:
15684 
          iprot.skip(ftype)
15685 
      else:
15686 
        iprot.skip(ftype)
15687 
      iprot.readFieldEnd()
15688 
    iprot.readStructEnd()
15689 
 
15690 
  def write(self, oprot):
15691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15693 
      return
15694 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15695 
    if self.ex is not None:
15696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15697 
      self.ex.write(oprot)
15698 
      oprot.writeFieldEnd()
15699 
    oprot.writeFieldStop()
15700 
    oprot.writeStructEnd()
15701 
 
15702 
  def validate(self):
15703 
    return
15704 
 
15705 
 
15706 
  def __repr__(self):
15707 
    L = ['%s=%r' % (key, value)
15708 
      for key, value in self.__dict__.iteritems()]
15709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15710 
 
15711 
  def __eq__(self, other):
15712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15713 
 
15714 
  def __ne__(self, other):
15715 
    return not (self == other)
15716 
 
15717 
class markOrderCancellationRequestDenied_args:
15718 
  """
15719 
  Attributes:
15720 
   - orderId
15721 
  """
15722 
 
15723 
  thrift_spec = (
15724 
    None, # 0
15725 
    (1, TType.I64, 'orderId', None, None, ), # 1
15726 
  )
15727 
 
15728 
  def __init__(self, orderId=None,):
15729 
    self.orderId = orderId
15730 
 
15731 
  def read(self, iprot):
15732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15734 
      return
15735 
    iprot.readStructBegin()
15736 
    while True:
15737 
      (fname, ftype, fid) = iprot.readFieldBegin()
15738 
      if ftype == TType.STOP:
15739 
        break
15740 
      if fid == 1:
15741 
        if ftype == TType.I64:
15742 
          self.orderId = iprot.readI64();
15743 
        else:
15744 
          iprot.skip(ftype)
15745 
      else:
15746 
        iprot.skip(ftype)
15747 
      iprot.readFieldEnd()
15748 
    iprot.readStructEnd()
15749 
 
15750 
  def write(self, oprot):
15751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15753 
      return
15754 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15755 
    if self.orderId is not None:
15756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15757 
      oprot.writeI64(self.orderId)
15758 
      oprot.writeFieldEnd()
15759 
    oprot.writeFieldStop()
15760 
    oprot.writeStructEnd()
15761 
 
15762 
  def validate(self):
15763 
    return
15764 
 
15765 
 
15766 
  def __repr__(self):
15767 
    L = ['%s=%r' % (key, value)
15768 
      for key, value in self.__dict__.iteritems()]
15769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15770 
 
15771 
  def __eq__(self, other):
15772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15773 
 
15774 
  def __ne__(self, other):
15775 
    return not (self == other)
15776 
 
15777 
class markOrderCancellationRequestDenied_result:
15778 
  """
15779 
  Attributes:
15780 
   - ex
15781 
  """
15782 
 
15783 
  thrift_spec = (
15784 
    None, # 0
15785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15786 
  )
15787 
 
15788 
  def __init__(self, ex=None,):
15789 
    self.ex = ex
15790 
 
15791 
  def read(self, iprot):
15792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15794 
      return
15795 
    iprot.readStructBegin()
15796 
    while True:
15797 
      (fname, ftype, fid) = iprot.readFieldBegin()
15798 
      if ftype == TType.STOP:
15799 
        break
15800 
      if fid == 1:
15801 
        if ftype == TType.STRUCT:
15802 
          self.ex = TransactionServiceException()
15803 
          self.ex.read(iprot)
15804 
        else:
15805 
          iprot.skip(ftype)
15806 
      else:
15807 
        iprot.skip(ftype)
15808 
      iprot.readFieldEnd()
15809 
    iprot.readStructEnd()
15810 
 
15811 
  def write(self, oprot):
15812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15814 
      return
15815 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15816 
    if self.ex is not None:
15817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15818 
      self.ex.write(oprot)
15819 
      oprot.writeFieldEnd()
15820 
    oprot.writeFieldStop()
15821 
    oprot.writeStructEnd()
15822 
 
15823 
  def validate(self):
15824 
    return
15825 
 
15826 
 
15827 
  def __repr__(self):
15828 
    L = ['%s=%r' % (key, value)
15829 
      for key, value in self.__dict__.iteritems()]
15830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15831 
 
15832 
  def __eq__(self, other):
15833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15834 
 
15835 
  def __ne__(self, other):
15836 
    return not (self == other)
15837 
 
4258 rajveer 15838 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15839 
  """
15840 
  Attributes:
4258 rajveer 15841 
   - transactionId
4247 rajveer 15842 
  """
15843 
 
15844 
  thrift_spec = (
15845 
    None, # 0
4258 rajveer 15846 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15847 
  )
15848 
 
4258 rajveer 15849 
  def __init__(self, transactionId=None,):
15850 
    self.transactionId = transactionId
4247 rajveer 15851 
 
15852 
  def read(self, iprot):
15853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15855 
      return
15856 
    iprot.readStructBegin()
15857 
    while True:
15858 
      (fname, ftype, fid) = iprot.readFieldBegin()
15859 
      if ftype == TType.STOP:
15860 
        break
15861 
      if fid == 1:
15862 
        if ftype == TType.I64:
4258 rajveer 15863 
          self.transactionId = iprot.readI64();
4247 rajveer 15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      else:
15867 
        iprot.skip(ftype)
15868 
      iprot.readFieldEnd()
15869 
    iprot.readStructEnd()
15870 
 
15871 
  def write(self, oprot):
15872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15874 
      return
4258 rajveer 15875 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15876 
    if self.transactionId is not None:
15877 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15878 
      oprot.writeI64(self.transactionId)
4247 rajveer 15879 
      oprot.writeFieldEnd()
15880 
    oprot.writeFieldStop()
15881 
    oprot.writeStructEnd()
15882 
 
15883 
  def validate(self):
15884 
    return
15885 
 
15886 
 
15887 
  def __repr__(self):
15888 
    L = ['%s=%r' % (key, value)
15889 
      for key, value in self.__dict__.iteritems()]
15890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15891 
 
15892 
  def __eq__(self, other):
15893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15894 
 
15895 
  def __ne__(self, other):
15896 
    return not (self == other)
15897 
 
4258 rajveer 15898 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15899 
  """
15900 
  Attributes:
15901 
   - ex
15902 
  """
15903 
 
15904 
  thrift_spec = (
15905 
    None, # 0
15906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15907 
  )
15908 
 
15909 
  def __init__(self, ex=None,):
15910 
    self.ex = ex
15911 
 
15912 
  def read(self, iprot):
15913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15915 
      return
15916 
    iprot.readStructBegin()
15917 
    while True:
15918 
      (fname, ftype, fid) = iprot.readFieldBegin()
15919 
      if ftype == TType.STOP:
15920 
        break
15921 
      if fid == 1:
15922 
        if ftype == TType.STRUCT:
15923 
          self.ex = TransactionServiceException()
15924 
          self.ex.read(iprot)
15925 
        else:
15926 
          iprot.skip(ftype)
15927 
      else:
15928 
        iprot.skip(ftype)
15929 
      iprot.readFieldEnd()
15930 
    iprot.readStructEnd()
15931 
 
15932 
  def write(self, oprot):
15933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15935 
      return
4258 rajveer 15936 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15937 
    if self.ex is not None:
15938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15939 
      self.ex.write(oprot)
15940 
      oprot.writeFieldEnd()
15941 
    oprot.writeFieldStop()
15942 
    oprot.writeStructEnd()
15943 
 
15944 
  def validate(self):
15945 
    return
15946 
 
15947 
 
15948 
  def __repr__(self):
15949 
    L = ['%s=%r' % (key, value)
15950 
      for key, value in self.__dict__.iteritems()]
15951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15952 
 
15953 
  def __eq__(self, other):
15954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15955 
 
15956 
  def __ne__(self, other):
15957 
    return not (self == other)
4259 anupam.sin 15958 
 
15959 
class refundTransaction_args:
15960 
  """
15961 
  Attributes:
15962 
   - transactionId
15963 
   - refundedBy
15964 
   - reason
15965 
  """
15966 
 
15967 
  thrift_spec = (
15968 
    None, # 0
15969 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15970 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15971 
    (3, TType.STRING, 'reason', None, None, ), # 3
15972 
  )
15973 
 
15974 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15975 
    self.transactionId = transactionId
15976 
    self.refundedBy = refundedBy
15977 
    self.reason = reason
15978 
 
15979 
  def read(self, iprot):
15980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15982 
      return
15983 
    iprot.readStructBegin()
15984 
    while True:
15985 
      (fname, ftype, fid) = iprot.readFieldBegin()
15986 
      if ftype == TType.STOP:
15987 
        break
15988 
      if fid == 1:
15989 
        if ftype == TType.I64:
15990 
          self.transactionId = iprot.readI64();
15991 
        else:
15992 
          iprot.skip(ftype)
15993 
      elif fid == 2:
15994 
        if ftype == TType.STRING:
15995 
          self.refundedBy = iprot.readString();
15996 
        else:
15997 
          iprot.skip(ftype)
15998 
      elif fid == 3:
15999 
        if ftype == TType.STRING:
16000 
          self.reason = iprot.readString();
16001 
        else:
16002 
          iprot.skip(ftype)
16003 
      else:
16004 
        iprot.skip(ftype)
16005 
      iprot.readFieldEnd()
16006 
    iprot.readStructEnd()
16007 
 
16008 
  def write(self, oprot):
16009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16011 
      return
16012 
    oprot.writeStructBegin('refundTransaction_args')
16013 
    if self.transactionId is not None:
16014 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16015 
      oprot.writeI64(self.transactionId)
16016 
      oprot.writeFieldEnd()
16017 
    if self.refundedBy is not None:
16018 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16019 
      oprot.writeString(self.refundedBy)
16020 
      oprot.writeFieldEnd()
16021 
    if self.reason is not None:
16022 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16023 
      oprot.writeString(self.reason)
16024 
      oprot.writeFieldEnd()
16025 
    oprot.writeFieldStop()
16026 
    oprot.writeStructEnd()
16027 
 
16028 
  def validate(self):
16029 
    return
16030 
 
16031 
 
16032 
  def __repr__(self):
16033 
    L = ['%s=%r' % (key, value)
16034 
      for key, value in self.__dict__.iteritems()]
16035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16036 
 
16037 
  def __eq__(self, other):
16038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16039 
 
16040 
  def __ne__(self, other):
16041 
    return not (self == other)
16042 
 
16043 
class refundTransaction_result:
16044 
  """
16045 
  Attributes:
16046 
   - ex
16047 
  """
16048 
 
16049 
  thrift_spec = (
16050 
    None, # 0
16051 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16052 
  )
16053 
 
16054 
  def __init__(self, ex=None,):
16055 
    self.ex = ex
16056 
 
16057 
  def read(self, iprot):
16058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16060 
      return
16061 
    iprot.readStructBegin()
16062 
    while True:
16063 
      (fname, ftype, fid) = iprot.readFieldBegin()
16064 
      if ftype == TType.STOP:
16065 
        break
16066 
      if fid == 1:
16067 
        if ftype == TType.STRUCT:
16068 
          self.ex = TransactionServiceException()
16069 
          self.ex.read(iprot)
16070 
        else:
16071 
          iprot.skip(ftype)
16072 
      else:
16073 
        iprot.skip(ftype)
16074 
      iprot.readFieldEnd()
16075 
    iprot.readStructEnd()
16076 
 
16077 
  def write(self, oprot):
16078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16080 
      return
16081 
    oprot.writeStructBegin('refundTransaction_result')
16082 
    if self.ex is not None:
16083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16084 
      self.ex.write(oprot)
16085 
      oprot.writeFieldEnd()
16086 
    oprot.writeFieldStop()
16087 
    oprot.writeStructEnd()
16088 
 
16089 
  def validate(self):
16090 
    return
16091 
 
16092 
 
16093 
  def __repr__(self):
16094 
    L = ['%s=%r' % (key, value)
16095 
      for key, value in self.__dict__.iteritems()]
16096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16097 
 
16098 
  def __eq__(self, other):
16099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16100 
 
16101 
  def __ne__(self, other):
16102 
    return not (self == other)
4285 rajveer 16103 
 
4324 mandeep.dh 16104 
class updateShipmentAddress_args:
16105 
  """
16106 
  Attributes:
16107 
   - orderId
16108 
   - addressId
16109 
  """
16110 
 
16111 
  thrift_spec = (
16112 
    None, # 0
16113 
    (1, TType.I64, 'orderId', None, None, ), # 1
16114 
    (2, TType.I64, 'addressId', None, None, ), # 2
16115 
  )
16116 
 
16117 
  def __init__(self, orderId=None, addressId=None,):
16118 
    self.orderId = orderId
16119 
    self.addressId = addressId
16120 
 
16121 
  def read(self, iprot):
16122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16124 
      return
16125 
    iprot.readStructBegin()
16126 
    while True:
16127 
      (fname, ftype, fid) = iprot.readFieldBegin()
16128 
      if ftype == TType.STOP:
16129 
        break
16130 
      if fid == 1:
16131 
        if ftype == TType.I64:
16132 
          self.orderId = iprot.readI64();
16133 
        else:
16134 
          iprot.skip(ftype)
16135 
      elif fid == 2:
16136 
        if ftype == TType.I64:
16137 
          self.addressId = iprot.readI64();
16138 
        else:
16139 
          iprot.skip(ftype)
16140 
      else:
16141 
        iprot.skip(ftype)
16142 
      iprot.readFieldEnd()
16143 
    iprot.readStructEnd()
16144 
 
16145 
  def write(self, oprot):
16146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16148 
      return
16149 
    oprot.writeStructBegin('updateShipmentAddress_args')
16150 
    if self.orderId is not None:
16151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16152 
      oprot.writeI64(self.orderId)
16153 
      oprot.writeFieldEnd()
16154 
    if self.addressId is not None:
16155 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16156 
      oprot.writeI64(self.addressId)
16157 
      oprot.writeFieldEnd()
16158 
    oprot.writeFieldStop()
16159 
    oprot.writeStructEnd()
16160 
 
16161 
  def validate(self):
16162 
    return
16163 
 
16164 
 
16165 
  def __repr__(self):
16166 
    L = ['%s=%r' % (key, value)
16167 
      for key, value in self.__dict__.iteritems()]
16168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16169 
 
16170 
  def __eq__(self, other):
16171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16172 
 
16173 
  def __ne__(self, other):
16174 
    return not (self == other)
16175 
 
16176 
class updateShipmentAddress_result:
16177 
  """
16178 
  Attributes:
16179 
   - ex
16180 
  """
16181 
 
16182 
  thrift_spec = (
16183 
    None, # 0
16184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16185 
  )
16186 
 
16187 
  def __init__(self, ex=None,):
16188 
    self.ex = ex
16189 
 
16190 
  def read(self, iprot):
16191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16193 
      return
16194 
    iprot.readStructBegin()
16195 
    while True:
16196 
      (fname, ftype, fid) = iprot.readFieldBegin()
16197 
      if ftype == TType.STOP:
16198 
        break
16199 
      if fid == 1:
16200 
        if ftype == TType.STRUCT:
16201 
          self.ex = TransactionServiceException()
16202 
          self.ex.read(iprot)
16203 
        else:
16204 
          iprot.skip(ftype)
16205 
      else:
16206 
        iprot.skip(ftype)
16207 
      iprot.readFieldEnd()
16208 
    iprot.readStructEnd()
16209 
 
16210 
  def write(self, oprot):
16211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16213 
      return
16214 
    oprot.writeStructBegin('updateShipmentAddress_result')
16215 
    if self.ex is not None:
16216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16217 
      self.ex.write(oprot)
16218 
      oprot.writeFieldEnd()
16219 
    oprot.writeFieldStop()
16220 
    oprot.writeStructEnd()
16221 
 
16222 
  def validate(self):
16223 
    return
16224 
 
16225 
 
16226 
  def __repr__(self):
16227 
    L = ['%s=%r' % (key, value)
16228 
      for key, value in self.__dict__.iteritems()]
16229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16230 
 
16231 
  def __eq__(self, other):
16232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16233 
 
16234 
  def __ne__(self, other):
16235 
    return not (self == other)
16236 
 
4285 rajveer 16237 
class acceptOrdersForItemId_args:
16238 
  """
16239 
  Attributes:
16240 
   - itemId
16241 
   - inventory
16242 
  """
16243 
 
16244 
  thrift_spec = (
16245 
    None, # 0
16246 
    (1, TType.I64, 'itemId', None, None, ), # 1
16247 
    (2, TType.I64, 'inventory', None, None, ), # 2
16248 
  )
16249 
 
16250 
  def __init__(self, itemId=None, inventory=None,):
16251 
    self.itemId = itemId
16252 
    self.inventory = inventory
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      if fid == 1:
16264 
        if ftype == TType.I64:
16265 
          self.itemId = iprot.readI64();
16266 
        else:
16267 
          iprot.skip(ftype)
16268 
      elif fid == 2:
16269 
        if ftype == TType.I64:
16270 
          self.inventory = iprot.readI64();
16271 
        else:
16272 
          iprot.skip(ftype)
16273 
      else:
16274 
        iprot.skip(ftype)
16275 
      iprot.readFieldEnd()
16276 
    iprot.readStructEnd()
16277 
 
16278 
  def write(self, oprot):
16279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16281 
      return
16282 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16283 
    if self.itemId is not None:
16284 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16285 
      oprot.writeI64(self.itemId)
16286 
      oprot.writeFieldEnd()
16287 
    if self.inventory is not None:
16288 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16289 
      oprot.writeI64(self.inventory)
16290 
      oprot.writeFieldEnd()
16291 
    oprot.writeFieldStop()
16292 
    oprot.writeStructEnd()
16293 
 
16294 
  def validate(self):
16295 
    return
16296 
 
16297 
 
16298 
  def __repr__(self):
16299 
    L = ['%s=%r' % (key, value)
16300 
      for key, value in self.__dict__.iteritems()]
16301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16302 
 
16303 
  def __eq__(self, other):
16304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16305 
 
16306 
  def __ne__(self, other):
16307 
    return not (self == other)
16308 
 
16309 
class acceptOrdersForItemId_result:
16310 
  """
16311 
  Attributes:
16312 
   - success
16313 
   - ex
16314 
  """
16315 
 
16316 
  thrift_spec = (
16317 
    (0, TType.BOOL, 'success', None, None, ), # 0
16318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16319 
  )
16320 
 
16321 
  def __init__(self, success=None, ex=None,):
16322 
    self.success = success
16323 
    self.ex = ex
16324 
 
16325 
  def read(self, iprot):
16326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16328 
      return
16329 
    iprot.readStructBegin()
16330 
    while True:
16331 
      (fname, ftype, fid) = iprot.readFieldBegin()
16332 
      if ftype == TType.STOP:
16333 
        break
16334 
      if fid == 0:
16335 
        if ftype == TType.BOOL:
16336 
          self.success = iprot.readBool();
16337 
        else:
16338 
          iprot.skip(ftype)
16339 
      elif fid == 1:
16340 
        if ftype == TType.STRUCT:
16341 
          self.ex = TransactionServiceException()
16342 
          self.ex.read(iprot)
16343 
        else:
16344 
          iprot.skip(ftype)
16345 
      else:
16346 
        iprot.skip(ftype)
16347 
      iprot.readFieldEnd()
16348 
    iprot.readStructEnd()
16349 
 
16350 
  def write(self, oprot):
16351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16353 
      return
16354 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16355 
    if self.success is not None:
16356 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16357 
      oprot.writeBool(self.success)
16358 
      oprot.writeFieldEnd()
16359 
    if self.ex is not None:
16360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16361 
      self.ex.write(oprot)
16362 
      oprot.writeFieldEnd()
16363 
    oprot.writeFieldStop()
16364 
    oprot.writeStructEnd()
16365 
 
16366 
  def validate(self):
16367 
    return
16368 
 
16369 
 
16370 
  def __repr__(self):
16371 
    L = ['%s=%r' % (key, value)
16372 
      for key, value in self.__dict__.iteritems()]
16373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16374 
 
16375 
  def __eq__(self, other):
16376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16377 
 
16378 
  def __ne__(self, other):
16379 
    return not (self == other)
4303 rajveer 16380 
 
16381 
class markOrdersAsPORaised_args:
16382 
  """
16383 
  Attributes:
16384 
   - vendorId
16385 
   - itemId
16386 
   - quantity
16387 
   - estimate
4369 rajveer 16388 
   - isReminder
4303 rajveer 16389 
  """
16390 
 
16391 
  thrift_spec = (
16392 
    None, # 0
16393 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16394 
    (2, TType.I64, 'itemId', None, None, ), # 2
16395 
    (3, TType.I64, 'quantity', None, None, ), # 3
16396 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16397 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16398 
  )
16399 
 
4369 rajveer 16400 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16401 
    self.vendorId = vendorId
16402 
    self.itemId = itemId
16403 
    self.quantity = quantity
16404 
    self.estimate = estimate
4369 rajveer 16405 
    self.isReminder = isReminder
4303 rajveer 16406 
 
16407 
  def read(self, iprot):
16408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16410 
      return
16411 
    iprot.readStructBegin()
16412 
    while True:
16413 
      (fname, ftype, fid) = iprot.readFieldBegin()
16414 
      if ftype == TType.STOP:
16415 
        break
16416 
      if fid == 1:
16417 
        if ftype == TType.I64:
16418 
          self.vendorId = iprot.readI64();
16419 
        else:
16420 
          iprot.skip(ftype)
16421 
      elif fid == 2:
16422 
        if ftype == TType.I64:
16423 
          self.itemId = iprot.readI64();
16424 
        else:
16425 
          iprot.skip(ftype)
16426 
      elif fid == 3:
16427 
        if ftype == TType.I64:
16428 
          self.quantity = iprot.readI64();
16429 
        else:
16430 
          iprot.skip(ftype)
16431 
      elif fid == 4:
16432 
        if ftype == TType.I64:
16433 
          self.estimate = iprot.readI64();
16434 
        else:
16435 
          iprot.skip(ftype)
4369 rajveer 16436 
      elif fid == 5:
16437 
        if ftype == TType.BOOL:
16438 
          self.isReminder = iprot.readBool();
16439 
        else:
16440 
          iprot.skip(ftype)
4303 rajveer 16441 
      else:
16442 
        iprot.skip(ftype)
16443 
      iprot.readFieldEnd()
16444 
    iprot.readStructEnd()
16445 
 
16446 
  def write(self, oprot):
16447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16449 
      return
16450 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16451 
    if self.vendorId is not None:
16452 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16453 
      oprot.writeI64(self.vendorId)
16454 
      oprot.writeFieldEnd()
16455 
    if self.itemId is not None:
16456 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16457 
      oprot.writeI64(self.itemId)
16458 
      oprot.writeFieldEnd()
16459 
    if self.quantity is not None:
16460 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16461 
      oprot.writeI64(self.quantity)
16462 
      oprot.writeFieldEnd()
16463 
    if self.estimate is not None:
16464 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16465 
      oprot.writeI64(self.estimate)
16466 
      oprot.writeFieldEnd()
4369 rajveer 16467 
    if self.isReminder is not None:
16468 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16469 
      oprot.writeBool(self.isReminder)
16470 
      oprot.writeFieldEnd()
4303 rajveer 16471 
    oprot.writeFieldStop()
16472 
    oprot.writeStructEnd()
16473 
 
16474 
  def validate(self):
16475 
    return
16476 
 
16477 
 
16478 
  def __repr__(self):
16479 
    L = ['%s=%r' % (key, value)
16480 
      for key, value in self.__dict__.iteritems()]
16481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16482 
 
16483 
  def __eq__(self, other):
16484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16485 
 
16486 
  def __ne__(self, other):
16487 
    return not (self == other)
16488 
 
16489 
class markOrdersAsPORaised_result:
16490 
  """
16491 
  Attributes:
16492 
   - ex
16493 
  """
16494 
 
16495 
  thrift_spec = (
16496 
    None, # 0
16497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16498 
  )
16499 
 
16500 
  def __init__(self, ex=None,):
16501 
    self.ex = ex
16502 
 
16503 
  def read(self, iprot):
16504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16506 
      return
16507 
    iprot.readStructBegin()
16508 
    while True:
16509 
      (fname, ftype, fid) = iprot.readFieldBegin()
16510 
      if ftype == TType.STOP:
16511 
        break
16512 
      if fid == 1:
16513 
        if ftype == TType.STRUCT:
16514 
          self.ex = TransactionServiceException()
16515 
          self.ex.read(iprot)
16516 
        else:
16517 
          iprot.skip(ftype)
16518 
      else:
16519 
        iprot.skip(ftype)
16520 
      iprot.readFieldEnd()
16521 
    iprot.readStructEnd()
16522 
 
16523 
  def write(self, oprot):
16524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16526 
      return
16527 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16528 
    if self.ex is not None:
16529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16530 
      self.ex.write(oprot)
16531 
      oprot.writeFieldEnd()
16532 
    oprot.writeFieldStop()
16533 
    oprot.writeStructEnd()
16534 
 
16535 
  def validate(self):
16536 
    return
16537 
 
16538 
 
16539 
  def __repr__(self):
16540 
    L = ['%s=%r' % (key, value)
16541 
      for key, value in self.__dict__.iteritems()]
16542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16543 
 
16544 
  def __eq__(self, other):
16545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16546 
 
16547 
  def __ne__(self, other):
16548 
    return not (self == other)
16549 
 
16550 
class markOrdersAsReversalInitiated_args:
16551 
  """
16552 
  Attributes:
16553 
   - vendorId
16554 
   - itemId
16555 
   - quantity
16556 
   - estimate
4369 rajveer 16557 
   - isReminder
4303 rajveer 16558 
  """
16559 
 
16560 
  thrift_spec = (
16561 
    None, # 0
16562 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16563 
    (2, TType.I64, 'itemId', None, None, ), # 2
16564 
    (3, TType.I64, 'quantity', None, None, ), # 3
16565 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16566 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16567 
  )
16568 
 
4369 rajveer 16569 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16570 
    self.vendorId = vendorId
16571 
    self.itemId = itemId
16572 
    self.quantity = quantity
16573 
    self.estimate = estimate
4369 rajveer 16574 
    self.isReminder = isReminder
4303 rajveer 16575 
 
16576 
  def read(self, iprot):
16577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16579 
      return
16580 
    iprot.readStructBegin()
16581 
    while True:
16582 
      (fname, ftype, fid) = iprot.readFieldBegin()
16583 
      if ftype == TType.STOP:
16584 
        break
16585 
      if fid == 1:
16586 
        if ftype == TType.I64:
16587 
          self.vendorId = iprot.readI64();
16588 
        else:
16589 
          iprot.skip(ftype)
16590 
      elif fid == 2:
16591 
        if ftype == TType.I64:
16592 
          self.itemId = iprot.readI64();
16593 
        else:
16594 
          iprot.skip(ftype)
16595 
      elif fid == 3:
16596 
        if ftype == TType.I64:
16597 
          self.quantity = iprot.readI64();
16598 
        else:
16599 
          iprot.skip(ftype)
16600 
      elif fid == 4:
16601 
        if ftype == TType.I64:
16602 
          self.estimate = iprot.readI64();
16603 
        else:
16604 
          iprot.skip(ftype)
4369 rajveer 16605 
      elif fid == 5:
16606 
        if ftype == TType.BOOL:
16607 
          self.isReminder = iprot.readBool();
16608 
        else:
16609 
          iprot.skip(ftype)
4303 rajveer 16610 
      else:
16611 
        iprot.skip(ftype)
16612 
      iprot.readFieldEnd()
16613 
    iprot.readStructEnd()
16614 
 
16615 
  def write(self, oprot):
16616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16618 
      return
16619 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16620 
    if self.vendorId is not None:
16621 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16622 
      oprot.writeI64(self.vendorId)
16623 
      oprot.writeFieldEnd()
16624 
    if self.itemId is not None:
16625 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16626 
      oprot.writeI64(self.itemId)
16627 
      oprot.writeFieldEnd()
16628 
    if self.quantity is not None:
16629 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16630 
      oprot.writeI64(self.quantity)
16631 
      oprot.writeFieldEnd()
16632 
    if self.estimate is not None:
16633 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16634 
      oprot.writeI64(self.estimate)
16635 
      oprot.writeFieldEnd()
4369 rajveer 16636 
    if self.isReminder is not None:
16637 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16638 
      oprot.writeBool(self.isReminder)
16639 
      oprot.writeFieldEnd()
4303 rajveer 16640 
    oprot.writeFieldStop()
16641 
    oprot.writeStructEnd()
16642 
 
16643 
  def validate(self):
16644 
    return
16645 
 
16646 
 
16647 
  def __repr__(self):
16648 
    L = ['%s=%r' % (key, value)
16649 
      for key, value in self.__dict__.iteritems()]
16650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16651 
 
16652 
  def __eq__(self, other):
16653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16654 
 
16655 
  def __ne__(self, other):
16656 
    return not (self == other)
16657 
 
16658 
class markOrdersAsReversalInitiated_result:
16659 
  """
16660 
  Attributes:
16661 
   - ex
16662 
  """
16663 
 
16664 
  thrift_spec = (
16665 
    None, # 0
16666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16667 
  )
16668 
 
16669 
  def __init__(self, ex=None,):
16670 
    self.ex = ex
16671 
 
16672 
  def read(self, iprot):
16673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16675 
      return
16676 
    iprot.readStructBegin()
16677 
    while True:
16678 
      (fname, ftype, fid) = iprot.readFieldBegin()
16679 
      if ftype == TType.STOP:
16680 
        break
16681 
      if fid == 1:
16682 
        if ftype == TType.STRUCT:
16683 
          self.ex = TransactionServiceException()
16684 
          self.ex.read(iprot)
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16697 
    if self.ex is not None:
16698 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16699 
      self.ex.write(oprot)
16700 
      oprot.writeFieldEnd()
16701 
    oprot.writeFieldStop()
16702 
    oprot.writeStructEnd()
16703 
 
16704 
  def validate(self):
16705 
    return
16706 
 
16707 
 
16708 
  def __repr__(self):
16709 
    L = ['%s=%r' % (key, value)
16710 
      for key, value in self.__dict__.iteritems()]
16711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16712 
 
16713 
  def __eq__(self, other):
16714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16715 
 
16716 
  def __ne__(self, other):
16717 
    return not (self == other)
16718 
 
16719 
class markOrdersAsNotAvailabke_args:
16720 
  """
16721 
  Attributes:
16722 
   - vendorId
16723 
   - itemId
16724 
   - quantity
16725 
   - estimate
4369 rajveer 16726 
   - isReminder
4303 rajveer 16727 
  """
16728 
 
16729 
  thrift_spec = (
16730 
    None, # 0
16731 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16732 
    (2, TType.I64, 'itemId', None, None, ), # 2
16733 
    (3, TType.I64, 'quantity', None, None, ), # 3
16734 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16735 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16736 
  )
16737 
 
4369 rajveer 16738 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16739 
    self.vendorId = vendorId
16740 
    self.itemId = itemId
16741 
    self.quantity = quantity
16742 
    self.estimate = estimate
4369 rajveer 16743 
    self.isReminder = isReminder
4303 rajveer 16744 
 
16745 
  def read(self, iprot):
16746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16748 
      return
16749 
    iprot.readStructBegin()
16750 
    while True:
16751 
      (fname, ftype, fid) = iprot.readFieldBegin()
16752 
      if ftype == TType.STOP:
16753 
        break
16754 
      if fid == 1:
16755 
        if ftype == TType.I64:
16756 
          self.vendorId = iprot.readI64();
16757 
        else:
16758 
          iprot.skip(ftype)
16759 
      elif fid == 2:
16760 
        if ftype == TType.I64:
16761 
          self.itemId = iprot.readI64();
16762 
        else:
16763 
          iprot.skip(ftype)
16764 
      elif fid == 3:
16765 
        if ftype == TType.I64:
16766 
          self.quantity = iprot.readI64();
16767 
        else:
16768 
          iprot.skip(ftype)
16769 
      elif fid == 4:
16770 
        if ftype == TType.I64:
16771 
          self.estimate = iprot.readI64();
16772 
        else:
16773 
          iprot.skip(ftype)
4369 rajveer 16774 
      elif fid == 5:
16775 
        if ftype == TType.BOOL:
16776 
          self.isReminder = iprot.readBool();
16777 
        else:
16778 
          iprot.skip(ftype)
4303 rajveer 16779 
      else:
16780 
        iprot.skip(ftype)
16781 
      iprot.readFieldEnd()
16782 
    iprot.readStructEnd()
16783 
 
16784 
  def write(self, oprot):
16785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16787 
      return
16788 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16789 
    if self.vendorId is not None:
16790 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16791 
      oprot.writeI64(self.vendorId)
16792 
      oprot.writeFieldEnd()
16793 
    if self.itemId is not None:
16794 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16795 
      oprot.writeI64(self.itemId)
16796 
      oprot.writeFieldEnd()
16797 
    if self.quantity is not None:
16798 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16799 
      oprot.writeI64(self.quantity)
16800 
      oprot.writeFieldEnd()
16801 
    if self.estimate is not None:
16802 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16803 
      oprot.writeI64(self.estimate)
16804 
      oprot.writeFieldEnd()
4369 rajveer 16805 
    if self.isReminder is not None:
16806 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16807 
      oprot.writeBool(self.isReminder)
16808 
      oprot.writeFieldEnd()
4303 rajveer 16809 
    oprot.writeFieldStop()
16810 
    oprot.writeStructEnd()
16811 
 
16812 
  def validate(self):
16813 
    return
16814 
 
16815 
 
16816 
  def __repr__(self):
16817 
    L = ['%s=%r' % (key, value)
16818 
      for key, value in self.__dict__.iteritems()]
16819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16820 
 
16821 
  def __eq__(self, other):
16822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16823 
 
16824 
  def __ne__(self, other):
16825 
    return not (self == other)
16826 
 
16827 
class markOrdersAsNotAvailabke_result:
16828 
  """
16829 
  Attributes:
16830 
   - ex
16831 
  """
16832 
 
16833 
  thrift_spec = (
16834 
    None, # 0
16835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16836 
  )
16837 
 
16838 
  def __init__(self, ex=None,):
16839 
    self.ex = ex
16840 
 
16841 
  def read(self, iprot):
16842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16844 
      return
16845 
    iprot.readStructBegin()
16846 
    while True:
16847 
      (fname, ftype, fid) = iprot.readFieldBegin()
16848 
      if ftype == TType.STOP:
16849 
        break
16850 
      if fid == 1:
16851 
        if ftype == TType.STRUCT:
16852 
          self.ex = TransactionServiceException()
16853 
          self.ex.read(iprot)
16854 
        else:
16855 
          iprot.skip(ftype)
16856 
      else:
16857 
        iprot.skip(ftype)
16858 
      iprot.readFieldEnd()
16859 
    iprot.readStructEnd()
16860 
 
16861 
  def write(self, oprot):
16862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16864 
      return
16865 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16866 
    if self.ex is not None:
16867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16868 
      self.ex.write(oprot)
16869 
      oprot.writeFieldEnd()
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
4369 rajveer 16887 
 
16888 
class markOrdersAsTimeout_args:
16889 
  """
16890 
  Attributes:
16891 
   - vendorId
16892 
  """
16893 
 
16894 
  thrift_spec = (
16895 
    None, # 0
16896 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16897 
  )
16898 
 
16899 
  def __init__(self, vendorId=None,):
16900 
    self.vendorId = vendorId
16901 
 
16902 
  def read(self, iprot):
16903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16905 
      return
16906 
    iprot.readStructBegin()
16907 
    while True:
16908 
      (fname, ftype, fid) = iprot.readFieldBegin()
16909 
      if ftype == TType.STOP:
16910 
        break
16911 
      if fid == 1:
16912 
        if ftype == TType.I64:
16913 
          self.vendorId = iprot.readI64();
16914 
        else:
16915 
          iprot.skip(ftype)
16916 
      else:
16917 
        iprot.skip(ftype)
16918 
      iprot.readFieldEnd()
16919 
    iprot.readStructEnd()
16920 
 
16921 
  def write(self, oprot):
16922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16924 
      return
16925 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16926 
    if self.vendorId is not None:
16927 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16928 
      oprot.writeI64(self.vendorId)
16929 
      oprot.writeFieldEnd()
16930 
    oprot.writeFieldStop()
16931 
    oprot.writeStructEnd()
16932 
 
16933 
  def validate(self):
16934 
    return
16935 
 
16936 
 
16937 
  def __repr__(self):
16938 
    L = ['%s=%r' % (key, value)
16939 
      for key, value in self.__dict__.iteritems()]
16940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16941 
 
16942 
  def __eq__(self, other):
16943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16944 
 
16945 
  def __ne__(self, other):
16946 
    return not (self == other)
16947 
 
16948 
class markOrdersAsTimeout_result:
16949 
  """
16950 
  Attributes:
16951 
   - success
16952 
   - ex
16953 
  """
16954 
 
16955 
  thrift_spec = (
16956 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16958 
  )
16959 
 
16960 
  def __init__(self, success=None, ex=None,):
16961 
    self.success = success
16962 
    self.ex = ex
16963 
 
16964 
  def read(self, iprot):
16965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16967 
      return
16968 
    iprot.readStructBegin()
16969 
    while True:
16970 
      (fname, ftype, fid) = iprot.readFieldBegin()
16971 
      if ftype == TType.STOP:
16972 
        break
16973 
      if fid == 0:
16974 
        if ftype == TType.MAP:
16975 
          self.success = {}
4586 mandeep.dh 16976 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16977 
          for _i279 in xrange(_size275):
16978 
            _key280 = iprot.readI32();
16979 
            _val281 = TimeoutSummary()
16980 
            _val281.read(iprot)
16981 
            self.success[_key280] = _val281
4369 rajveer 16982 
          iprot.readMapEnd()
16983 
        else:
16984 
          iprot.skip(ftype)
16985 
      elif fid == 1:
16986 
        if ftype == TType.STRUCT:
16987 
          self.ex = TransactionServiceException()
16988 
          self.ex.read(iprot)
16989 
        else:
16990 
          iprot.skip(ftype)
16991 
      else:
16992 
        iprot.skip(ftype)
16993 
      iprot.readFieldEnd()
16994 
    iprot.readStructEnd()
16995 
 
16996 
  def write(self, oprot):
16997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16999 
      return
17000 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17001 
    if self.success is not None:
17002 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17003 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 17004 
      for kiter282,viter283 in self.success.items():
17005 
        oprot.writeI32(kiter282)
17006 
        viter283.write(oprot)
4369 rajveer 17007 
      oprot.writeMapEnd()
17008 
      oprot.writeFieldEnd()
17009 
    if self.ex is not None:
17010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17011 
      self.ex.write(oprot)
17012 
      oprot.writeFieldEnd()
17013 
    oprot.writeFieldStop()
17014 
    oprot.writeStructEnd()
17015 
 
17016 
  def validate(self):
17017 
    return
17018 
 
17019 
 
17020 
  def __repr__(self):
17021 
    L = ['%s=%r' % (key, value)
17022 
      for key, value in self.__dict__.iteritems()]
17023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17024 
 
17025 
  def __eq__(self, other):
17026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17027 
 
17028 
  def __ne__(self, other):
17029 
    return not (self == other)
4386 anupam.sin 17030 
 
4662 rajveer 17031 
class markOrderAsLostInTransit_args:
17032 
  """
17033 
  Attributes:
17034 
   - orderId
17035 
  """
17036 
 
17037 
  thrift_spec = (
17038 
    None, # 0
17039 
    (1, TType.I64, 'orderId', None, None, ), # 1
17040 
  )
17041 
 
17042 
  def __init__(self, orderId=None,):
17043 
    self.orderId = orderId
17044 
 
17045 
  def read(self, iprot):
17046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17048 
      return
17049 
    iprot.readStructBegin()
17050 
    while True:
17051 
      (fname, ftype, fid) = iprot.readFieldBegin()
17052 
      if ftype == TType.STOP:
17053 
        break
17054 
      if fid == 1:
17055 
        if ftype == TType.I64:
17056 
          self.orderId = iprot.readI64();
17057 
        else:
17058 
          iprot.skip(ftype)
17059 
      else:
17060 
        iprot.skip(ftype)
17061 
      iprot.readFieldEnd()
17062 
    iprot.readStructEnd()
17063 
 
17064 
  def write(self, oprot):
17065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17067 
      return
17068 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17069 
    if self.orderId is not None:
17070 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17071 
      oprot.writeI64(self.orderId)
17072 
      oprot.writeFieldEnd()
17073 
    oprot.writeFieldStop()
17074 
    oprot.writeStructEnd()
17075 
 
17076 
  def validate(self):
17077 
    return
17078 
 
17079 
 
17080 
  def __repr__(self):
17081 
    L = ['%s=%r' % (key, value)
17082 
      for key, value in self.__dict__.iteritems()]
17083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17084 
 
17085 
  def __eq__(self, other):
17086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17087 
 
17088 
  def __ne__(self, other):
17089 
    return not (self == other)
17090 
 
17091 
class markOrderAsLostInTransit_result:
17092 
  """
17093 
  Attributes:
17094 
   - success
17095 
   - ex
17096 
  """
17097 
 
17098 
  thrift_spec = (
17099 
    (0, TType.BOOL, 'success', None, None, ), # 0
17100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17101 
  )
17102 
 
17103 
  def __init__(self, success=None, ex=None,):
17104 
    self.success = success
17105 
    self.ex = ex
17106 
 
17107 
  def read(self, iprot):
17108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17110 
      return
17111 
    iprot.readStructBegin()
17112 
    while True:
17113 
      (fname, ftype, fid) = iprot.readFieldBegin()
17114 
      if ftype == TType.STOP:
17115 
        break
17116 
      if fid == 0:
17117 
        if ftype == TType.BOOL:
17118 
          self.success = iprot.readBool();
17119 
        else:
17120 
          iprot.skip(ftype)
17121 
      elif fid == 1:
17122 
        if ftype == TType.STRUCT:
17123 
          self.ex = TransactionServiceException()
17124 
          self.ex.read(iprot)
17125 
        else:
17126 
          iprot.skip(ftype)
17127 
      else:
17128 
        iprot.skip(ftype)
17129 
      iprot.readFieldEnd()
17130 
    iprot.readStructEnd()
17131 
 
17132 
  def write(self, oprot):
17133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17135 
      return
17136 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17137 
    if self.success is not None:
17138 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17139 
      oprot.writeBool(self.success)
17140 
      oprot.writeFieldEnd()
17141 
    if self.ex is not None:
17142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17143 
      self.ex.write(oprot)
17144 
      oprot.writeFieldEnd()
17145 
    oprot.writeFieldStop()
17146 
    oprot.writeStructEnd()
17147 
 
17148 
  def validate(self):
17149 
    return
17150 
 
17151 
 
17152 
  def __repr__(self):
17153 
    L = ['%s=%r' % (key, value)
17154 
      for key, value in self.__dict__.iteritems()]
17155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17156 
 
17157 
  def __eq__(self, other):
17158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17159 
 
17160 
  def __ne__(self, other):
17161 
    return not (self == other)
17162 
 
4386 anupam.sin 17163 
class getOrderForAwb_args:
17164 
  """
17165 
  Attributes:
17166 
   - awb
17167 
  """
17168 
 
17169 
  thrift_spec = (
17170 
    None, # 0
17171 
    (1, TType.STRING, 'awb', None, None, ), # 1
17172 
  )
17173 
 
17174 
  def __init__(self, awb=None,):
17175 
    self.awb = awb
17176 
 
17177 
  def read(self, iprot):
17178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17180 
      return
17181 
    iprot.readStructBegin()
17182 
    while True:
17183 
      (fname, ftype, fid) = iprot.readFieldBegin()
17184 
      if ftype == TType.STOP:
17185 
        break
17186 
      if fid == 1:
17187 
        if ftype == TType.STRING:
17188 
          self.awb = iprot.readString();
17189 
        else:
17190 
          iprot.skip(ftype)
17191 
      else:
17192 
        iprot.skip(ftype)
17193 
      iprot.readFieldEnd()
17194 
    iprot.readStructEnd()
17195 
 
17196 
  def write(self, oprot):
17197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17199 
      return
17200 
    oprot.writeStructBegin('getOrderForAwb_args')
17201 
    if self.awb is not None:
17202 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17203 
      oprot.writeString(self.awb)
17204 
      oprot.writeFieldEnd()
17205 
    oprot.writeFieldStop()
17206 
    oprot.writeStructEnd()
17207 
 
17208 
  def validate(self):
17209 
    return
17210 
 
17211 
 
17212 
  def __repr__(self):
17213 
    L = ['%s=%r' % (key, value)
17214 
      for key, value in self.__dict__.iteritems()]
17215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17216 
 
17217 
  def __eq__(self, other):
17218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17219 
 
17220 
  def __ne__(self, other):
17221 
    return not (self == other)
17222 
 
17223 
class getOrderForAwb_result:
17224 
  """
17225 
  Attributes:
17226 
   - success
17227 
   - ex
17228 
  """
17229 
 
17230 
  thrift_spec = (
17231 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17233 
  )
17234 
 
17235 
  def __init__(self, success=None, ex=None,):
17236 
    self.success = success
17237 
    self.ex = ex
17238 
 
17239 
  def read(self, iprot):
17240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17242 
      return
17243 
    iprot.readStructBegin()
17244 
    while True:
17245 
      (fname, ftype, fid) = iprot.readFieldBegin()
17246 
      if ftype == TType.STOP:
17247 
        break
17248 
      if fid == 0:
17249 
        if ftype == TType.STRUCT:
17250 
          self.success = Order()
17251 
          self.success.read(iprot)
17252 
        else:
17253 
          iprot.skip(ftype)
17254 
      elif fid == 1:
17255 
        if ftype == TType.STRUCT:
17256 
          self.ex = TransactionServiceException()
17257 
          self.ex.read(iprot)
17258 
        else:
17259 
          iprot.skip(ftype)
17260 
      else:
17261 
        iprot.skip(ftype)
17262 
      iprot.readFieldEnd()
17263 
    iprot.readStructEnd()
17264 
 
17265 
  def write(self, oprot):
17266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17268 
      return
17269 
    oprot.writeStructBegin('getOrderForAwb_result')
17270 
    if self.success is not None:
17271 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17272 
      self.success.write(oprot)
17273 
      oprot.writeFieldEnd()
17274 
    if self.ex is not None:
17275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17276 
      self.ex.write(oprot)
17277 
      oprot.writeFieldEnd()
17278 
    oprot.writeFieldStop()
17279 
    oprot.writeStructEnd()
17280 
 
17281 
  def validate(self):
17282 
    return
17283 
 
17284 
 
17285 
  def __repr__(self):
17286 
    L = ['%s=%r' % (key, value)
17287 
      for key, value in self.__dict__.iteritems()]
17288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17289 
 
17290 
  def __eq__(self, other):
17291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17292 
 
17293 
  def __ne__(self, other):
17294 
    return not (self == other)
4506 phani.kuma 17295 
 
17296 
class getOrdersForProviderForStatus_args:
17297 
  """
17298 
  Attributes:
17299 
   - logistics_provider_id
17300 
   - order_status
17301 
  """
17302 
 
17303 
  thrift_spec = (
17304 
    None, # 0
17305 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17306 
    (2, TType.I32, 'order_status', None, None, ), # 2
17307 
  )
17308 
 
17309 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17310 
    self.logistics_provider_id = logistics_provider_id
17311 
    self.order_status = order_status
17312 
 
17313 
  def read(self, iprot):
17314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17316 
      return
17317 
    iprot.readStructBegin()
17318 
    while True:
17319 
      (fname, ftype, fid) = iprot.readFieldBegin()
17320 
      if ftype == TType.STOP:
17321 
        break
17322 
      if fid == 1:
17323 
        if ftype == TType.I64:
17324 
          self.logistics_provider_id = iprot.readI64();
17325 
        else:
17326 
          iprot.skip(ftype)
17327 
      elif fid == 2:
17328 
        if ftype == TType.I32:
17329 
          self.order_status = iprot.readI32();
17330 
        else:
17331 
          iprot.skip(ftype)
17332 
      else:
17333 
        iprot.skip(ftype)
17334 
      iprot.readFieldEnd()
17335 
    iprot.readStructEnd()
17336 
 
17337 
  def write(self, oprot):
17338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17340 
      return
17341 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17342 
    if self.logistics_provider_id is not None:
17343 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17344 
      oprot.writeI64(self.logistics_provider_id)
17345 
      oprot.writeFieldEnd()
17346 
    if self.order_status is not None:
17347 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17348 
      oprot.writeI32(self.order_status)
17349 
      oprot.writeFieldEnd()
17350 
    oprot.writeFieldStop()
17351 
    oprot.writeStructEnd()
17352 
 
17353 
  def validate(self):
17354 
    return
17355 
 
17356 
 
17357 
  def __repr__(self):
17358 
    L = ['%s=%r' % (key, value)
17359 
      for key, value in self.__dict__.iteritems()]
17360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17361 
 
17362 
  def __eq__(self, other):
17363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17364 
 
17365 
  def __ne__(self, other):
17366 
    return not (self == other)
17367 
 
17368 
class getOrdersForProviderForStatus_result:
17369 
  """
17370 
  Attributes:
17371 
   - success
17372 
   - ex
17373 
  """
17374 
 
17375 
  thrift_spec = (
17376 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17378 
  )
17379 
 
17380 
  def __init__(self, success=None, ex=None,):
17381 
    self.success = success
17382 
    self.ex = ex
17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      if fid == 0:
17394 
        if ftype == TType.LIST:
17395 
          self.success = []
4586 mandeep.dh 17396 
          (_etype287, _size284) = iprot.readListBegin()
17397 
          for _i288 in xrange(_size284):
17398 
            _elem289 = Order()
17399 
            _elem289.read(iprot)
17400 
            self.success.append(_elem289)
4506 phani.kuma 17401 
          iprot.readListEnd()
17402 
        else:
17403 
          iprot.skip(ftype)
17404 
      elif fid == 1:
17405 
        if ftype == TType.STRUCT:
17406 
          self.ex = TransactionServiceException()
17407 
          self.ex.read(iprot)
17408 
        else:
17409 
          iprot.skip(ftype)
17410 
      else:
17411 
        iprot.skip(ftype)
17412 
      iprot.readFieldEnd()
17413 
    iprot.readStructEnd()
17414 
 
17415 
  def write(self, oprot):
17416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17418 
      return
17419 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17420 
    if self.success is not None:
17421 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17422 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 17423 
      for iter290 in self.success:
17424 
        iter290.write(oprot)
4506 phani.kuma 17425 
      oprot.writeListEnd()
17426 
      oprot.writeFieldEnd()
17427 
    if self.ex is not None:
17428 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17429 
      self.ex.write(oprot)
17430 
      oprot.writeFieldEnd()
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
4600 varun.gupt 17448 
 
17449 
class getBilledOrdersForVendor_args:
17450 
  """
17451 
  Attributes:
17452 
   - vendorId
17453 
   - billingDateFrom
17454 
   - billingDateTo
17455 
  """
17456 
 
17457 
  thrift_spec = (
17458 
    None, # 0
17459 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17460 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17461 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17462 
  )
17463 
 
17464 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17465 
    self.vendorId = vendorId
17466 
    self.billingDateFrom = billingDateFrom
17467 
    self.billingDateTo = billingDateTo
17468 
 
17469 
  def read(self, iprot):
17470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17472 
      return
17473 
    iprot.readStructBegin()
17474 
    while True:
17475 
      (fname, ftype, fid) = iprot.readFieldBegin()
17476 
      if ftype == TType.STOP:
17477 
        break
17478 
      if fid == 1:
17479 
        if ftype == TType.I64:
17480 
          self.vendorId = iprot.readI64();
17481 
        else:
17482 
          iprot.skip(ftype)
17483 
      elif fid == 2:
17484 
        if ftype == TType.I64:
17485 
          self.billingDateFrom = iprot.readI64();
17486 
        else:
17487 
          iprot.skip(ftype)
17488 
      elif fid == 3:
17489 
        if ftype == TType.I64:
17490 
          self.billingDateTo = iprot.readI64();
17491 
        else:
17492 
          iprot.skip(ftype)
17493 
      else:
17494 
        iprot.skip(ftype)
17495 
      iprot.readFieldEnd()
17496 
    iprot.readStructEnd()
17497 
 
17498 
  def write(self, oprot):
17499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17501 
      return
17502 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17503 
    if self.vendorId is not None:
17504 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17505 
      oprot.writeI64(self.vendorId)
17506 
      oprot.writeFieldEnd()
17507 
    if self.billingDateFrom is not None:
17508 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17509 
      oprot.writeI64(self.billingDateFrom)
17510 
      oprot.writeFieldEnd()
17511 
    if self.billingDateTo is not None:
17512 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17513 
      oprot.writeI64(self.billingDateTo)
17514 
      oprot.writeFieldEnd()
17515 
    oprot.writeFieldStop()
17516 
    oprot.writeStructEnd()
17517 
 
17518 
  def validate(self):
17519 
    return
17520 
 
17521 
 
17522 
  def __repr__(self):
17523 
    L = ['%s=%r' % (key, value)
17524 
      for key, value in self.__dict__.iteritems()]
17525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17526 
 
17527 
  def __eq__(self, other):
17528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17529 
 
17530 
  def __ne__(self, other):
17531 
    return not (self == other)
17532 
 
17533 
class getBilledOrdersForVendor_result:
17534 
  """
17535 
  Attributes:
17536 
   - success
17537 
   - ex
17538 
  """
17539 
 
17540 
  thrift_spec = (
17541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17543 
  )
17544 
 
17545 
  def __init__(self, success=None, ex=None,):
17546 
    self.success = success
17547 
    self.ex = ex
17548 
 
17549 
  def read(self, iprot):
17550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17552 
      return
17553 
    iprot.readStructBegin()
17554 
    while True:
17555 
      (fname, ftype, fid) = iprot.readFieldBegin()
17556 
      if ftype == TType.STOP:
17557 
        break
17558 
      if fid == 0:
17559 
        if ftype == TType.LIST:
17560 
          self.success = []
17561 
          (_etype294, _size291) = iprot.readListBegin()
17562 
          for _i295 in xrange(_size291):
17563 
            _elem296 = Order()
17564 
            _elem296.read(iprot)
17565 
            self.success.append(_elem296)
17566 
          iprot.readListEnd()
17567 
        else:
17568 
          iprot.skip(ftype)
17569 
      elif fid == 1:
17570 
        if ftype == TType.STRUCT:
17571 
          self.ex = TransactionServiceException()
17572 
          self.ex.read(iprot)
17573 
        else:
17574 
          iprot.skip(ftype)
17575 
      else:
17576 
        iprot.skip(ftype)
17577 
      iprot.readFieldEnd()
17578 
    iprot.readStructEnd()
17579 
 
17580 
  def write(self, oprot):
17581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17583 
      return
17584 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17585 
    if self.success is not None:
17586 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17587 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17588 
      for iter297 in self.success:
17589 
        iter297.write(oprot)
17590 
      oprot.writeListEnd()
17591 
      oprot.writeFieldEnd()
17592 
    if self.ex is not None:
17593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17594 
      self.ex.write(oprot)
17595 
      oprot.writeFieldEnd()
17596 
    oprot.writeFieldStop()
17597 
    oprot.writeStructEnd()
17598 
 
17599 
  def validate(self):
17600 
    return
17601 
 
17602 
 
17603 
  def __repr__(self):
17604 
    L = ['%s=%r' % (key, value)
17605 
      for key, value in self.__dict__.iteritems()]
17606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17607 
 
17608 
  def __eq__(self, other):
17609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17610 
 
17611 
  def __ne__(self, other):
17612 
    return not (self == other)
17613 
 
4607 rajveer 17614 
class getSlippedSippingDateOrders_args:
17615 
 
17616 
  thrift_spec = (
17617 
  )
17618 
 
17619 
  def read(self, iprot):
17620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17622 
      return
17623 
    iprot.readStructBegin()
17624 
    while True:
17625 
      (fname, ftype, fid) = iprot.readFieldBegin()
17626 
      if ftype == TType.STOP:
17627 
        break
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('getSlippedSippingDateOrders_args')
17638 
    oprot.writeFieldStop()
17639 
    oprot.writeStructEnd()
17640 
 
17641 
  def validate(self):
17642 
    return
17643 
 
17644 
 
17645 
  def __repr__(self):
17646 
    L = ['%s=%r' % (key, value)
17647 
      for key, value in self.__dict__.iteritems()]
17648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17649 
 
17650 
  def __eq__(self, other):
17651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17652 
 
17653 
  def __ne__(self, other):
17654 
    return not (self == other)
17655 
 
17656 
class getSlippedSippingDateOrders_result:
17657 
  """
17658 
  Attributes:
17659 
   - success
17660 
   - ex
17661 
  """
17662 
 
17663 
  thrift_spec = (
17664 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17665 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17666 
  )
17667 
 
17668 
  def __init__(self, success=None, ex=None,):
17669 
    self.success = success
17670 
    self.ex = ex
17671 
 
17672 
  def read(self, iprot):
17673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17675 
      return
17676 
    iprot.readStructBegin()
17677 
    while True:
17678 
      (fname, ftype, fid) = iprot.readFieldBegin()
17679 
      if ftype == TType.STOP:
17680 
        break
17681 
      if fid == 0:
17682 
        if ftype == TType.LIST:
17683 
          self.success = []
17684 
          (_etype301, _size298) = iprot.readListBegin()
17685 
          for _i302 in xrange(_size298):
17686 
            _elem303 = Order()
17687 
            _elem303.read(iprot)
17688 
            self.success.append(_elem303)
17689 
          iprot.readListEnd()
17690 
        else:
17691 
          iprot.skip(ftype)
17692 
      elif fid == 1:
17693 
        if ftype == TType.STRUCT:
17694 
          self.ex = TransactionServiceException()
17695 
          self.ex.read(iprot)
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      else:
17699 
        iprot.skip(ftype)
17700 
      iprot.readFieldEnd()
17701 
    iprot.readStructEnd()
17702 
 
17703 
  def write(self, oprot):
17704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17706 
      return
17707 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17708 
    if self.success is not None:
17709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17711 
      for iter304 in self.success:
17712 
        iter304.write(oprot)
17713 
      oprot.writeListEnd()
17714 
      oprot.writeFieldEnd()
17715 
    if self.ex is not None:
17716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17717 
      self.ex.write(oprot)
17718 
      oprot.writeFieldEnd()
17719 
    oprot.writeFieldStop()
17720 
    oprot.writeStructEnd()
17721 
 
17722 
  def validate(self):
17723 
    return
17724 
 
17725 
 
17726 
  def __repr__(self):
17727 
    L = ['%s=%r' % (key, value)
17728 
      for key, value in self.__dict__.iteritems()]
17729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17730 
 
17731 
  def __eq__(self, other):
17732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17733 
 
17734 
  def __ne__(self, other):
17735 
    return not (self == other)
17736 
 
4709 rajveer 17737 
class getCancelledOrders_args:
17738 
  """
17739 
  Attributes:
17740 
   - cancelDateFrom
17741 
   - cancelDateTo
17742 
  """
17743 
 
17744 
  thrift_spec = (
17745 
    None, # 0
17746 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
17747 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
17748 
  )
17749 
 
17750 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
17751 
    self.cancelDateFrom = cancelDateFrom
17752 
    self.cancelDateTo = cancelDateTo
17753 
 
17754 
  def read(self, iprot):
17755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17757 
      return
17758 
    iprot.readStructBegin()
17759 
    while True:
17760 
      (fname, ftype, fid) = iprot.readFieldBegin()
17761 
      if ftype == TType.STOP:
17762 
        break
17763 
      if fid == 1:
17764 
        if ftype == TType.I64:
17765 
          self.cancelDateFrom = iprot.readI64();
17766 
        else:
17767 
          iprot.skip(ftype)
17768 
      elif fid == 2:
17769 
        if ftype == TType.I64:
17770 
          self.cancelDateTo = iprot.readI64();
17771 
        else:
17772 
          iprot.skip(ftype)
17773 
      else:
17774 
        iprot.skip(ftype)
17775 
      iprot.readFieldEnd()
17776 
    iprot.readStructEnd()
17777 
 
17778 
  def write(self, oprot):
17779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17781 
      return
17782 
    oprot.writeStructBegin('getCancelledOrders_args')
17783 
    if self.cancelDateFrom is not None:
17784 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
17785 
      oprot.writeI64(self.cancelDateFrom)
17786 
      oprot.writeFieldEnd()
17787 
    if self.cancelDateTo is not None:
17788 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
17789 
      oprot.writeI64(self.cancelDateTo)
17790 
      oprot.writeFieldEnd()
17791 
    oprot.writeFieldStop()
17792 
    oprot.writeStructEnd()
17793 
 
17794 
  def validate(self):
17795 
    return
17796 
 
17797 
 
17798 
  def __repr__(self):
17799 
    L = ['%s=%r' % (key, value)
17800 
      for key, value in self.__dict__.iteritems()]
17801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17802 
 
17803 
  def __eq__(self, other):
17804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17805 
 
17806 
  def __ne__(self, other):
17807 
    return not (self == other)
17808 
 
17809 
class getCancelledOrders_result:
17810 
  """
17811 
  Attributes:
17812 
   - success
17813 
   - ex
17814 
  """
17815 
 
17816 
  thrift_spec = (
17817 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17819 
  )
17820 
 
17821 
  def __init__(self, success=None, ex=None,):
17822 
    self.success = success
17823 
    self.ex = ex
17824 
 
17825 
  def read(self, iprot):
17826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17828 
      return
17829 
    iprot.readStructBegin()
17830 
    while True:
17831 
      (fname, ftype, fid) = iprot.readFieldBegin()
17832 
      if ftype == TType.STOP:
17833 
        break
17834 
      if fid == 0:
17835 
        if ftype == TType.LIST:
17836 
          self.success = []
17837 
          (_etype308, _size305) = iprot.readListBegin()
17838 
          for _i309 in xrange(_size305):
17839 
            _elem310 = Order()
17840 
            _elem310.read(iprot)
17841 
            self.success.append(_elem310)
17842 
          iprot.readListEnd()
17843 
        else:
17844 
          iprot.skip(ftype)
17845 
      elif fid == 1:
17846 
        if ftype == TType.STRUCT:
17847 
          self.ex = TransactionServiceException()
17848 
          self.ex.read(iprot)
17849 
        else:
17850 
          iprot.skip(ftype)
17851 
      else:
17852 
        iprot.skip(ftype)
17853 
      iprot.readFieldEnd()
17854 
    iprot.readStructEnd()
17855 
 
17856 
  def write(self, oprot):
17857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17859 
      return
17860 
    oprot.writeStructBegin('getCancelledOrders_result')
17861 
    if self.success is not None:
17862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17863 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17864 
      for iter311 in self.success:
17865 
        iter311.write(oprot)
17866 
      oprot.writeListEnd()
17867 
      oprot.writeFieldEnd()
17868 
    if self.ex is not None:
17869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17870 
      self.ex.write(oprot)
17871 
      oprot.writeFieldEnd()
17872 
    oprot.writeFieldStop()
17873 
    oprot.writeStructEnd()
17874 
 
17875 
  def validate(self):
17876 
    return
17877 
 
17878 
 
17879 
  def __repr__(self):
17880 
    L = ['%s=%r' % (key, value)
17881 
      for key, value in self.__dict__.iteritems()]
17882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17883 
 
17884 
  def __eq__(self, other):
17885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17886 
 
17887 
  def __ne__(self, other):
17888 
    return not (self == other)
17889 
 
4600 varun.gupt 17890 
class saveBluedartSettlements_args:
17891 
  """
17892 
  Attributes:
17893 
   - mapAWBAndAmount
17894 
  """
17895 
 
17896 
  thrift_spec = (
17897 
    None, # 0
17898 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17899 
  )
17900 
 
17901 
  def __init__(self, mapAWBAndAmount=None,):
17902 
    self.mapAWBAndAmount = mapAWBAndAmount
17903 
 
17904 
  def read(self, iprot):
17905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17907 
      return
17908 
    iprot.readStructBegin()
17909 
    while True:
17910 
      (fname, ftype, fid) = iprot.readFieldBegin()
17911 
      if ftype == TType.STOP:
17912 
        break
17913 
      if fid == 1:
17914 
        if ftype == TType.MAP:
17915 
          self.mapAWBAndAmount = {}
4709 rajveer 17916 
          (_ktype313, _vtype314, _size312 ) = iprot.readMapBegin()
17917 
          for _i316 in xrange(_size312):
17918 
            _key317 = iprot.readI64();
17919 
            _val318 = iprot.readDouble();
17920 
            self.mapAWBAndAmount[_key317] = _val318
4600 varun.gupt 17921 
          iprot.readMapEnd()
17922 
        else:
17923 
          iprot.skip(ftype)
17924 
      else:
17925 
        iprot.skip(ftype)
17926 
      iprot.readFieldEnd()
17927 
    iprot.readStructEnd()
17928 
 
17929 
  def write(self, oprot):
17930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17932 
      return
17933 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17934 
    if self.mapAWBAndAmount is not None:
17935 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17936 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4709 rajveer 17937 
      for kiter319,viter320 in self.mapAWBAndAmount.items():
17938 
        oprot.writeI64(kiter319)
17939 
        oprot.writeDouble(viter320)
4600 varun.gupt 17940 
      oprot.writeMapEnd()
17941 
      oprot.writeFieldEnd()
17942 
    oprot.writeFieldStop()
17943 
    oprot.writeStructEnd()
17944 
 
17945 
  def validate(self):
17946 
    return
17947 
 
17948 
 
17949 
  def __repr__(self):
17950 
    L = ['%s=%r' % (key, value)
17951 
      for key, value in self.__dict__.iteritems()]
17952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17953 
 
17954 
  def __eq__(self, other):
17955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17956 
 
17957 
  def __ne__(self, other):
17958 
    return not (self == other)
17959 
 
17960 
class saveBluedartSettlements_result:
17961 
  """
17962 
  Attributes:
17963 
   - ex
17964 
  """
17965 
 
17966 
  thrift_spec = (
17967 
    None, # 0
17968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17969 
  )
17970 
 
17971 
  def __init__(self, ex=None,):
17972 
    self.ex = ex
17973 
 
17974 
  def read(self, iprot):
17975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17977 
      return
17978 
    iprot.readStructBegin()
17979 
    while True:
17980 
      (fname, ftype, fid) = iprot.readFieldBegin()
17981 
      if ftype == TType.STOP:
17982 
        break
17983 
      if fid == 1:
17984 
        if ftype == TType.STRUCT:
17985 
          self.ex = TransactionServiceException()
17986 
          self.ex.read(iprot)
17987 
        else:
17988 
          iprot.skip(ftype)
17989 
      else:
17990 
        iprot.skip(ftype)
17991 
      iprot.readFieldEnd()
17992 
    iprot.readStructEnd()
17993 
 
17994 
  def write(self, oprot):
17995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17997 
      return
17998 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17999 
    if self.ex is not None:
18000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18001 
      self.ex.write(oprot)
18002 
      oprot.writeFieldEnd()
18003 
    oprot.writeFieldStop()
18004 
    oprot.writeStructEnd()
18005 
 
18006 
  def validate(self):
18007 
    return
18008 
 
18009 
 
18010 
  def __repr__(self):
18011 
    L = ['%s=%r' % (key, value)
18012 
      for key, value in self.__dict__.iteritems()]
18013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18014 
 
18015 
  def __eq__(self, other):
18016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18017 
 
18018 
  def __ne__(self, other):
18019 
    return not (self == other)
18020 
 
18021 
class savePaymentSettlements_args:
18022 
  """
18023 
  Attributes:
18024 
   - settlementDate
18025 
   - paymentGatewayId
18026 
   - paymentId
18027 
   - serviceTax
18028 
   - otherCharges
18029 
   - netCollection
18030 
  """
18031 
 
18032 
  thrift_spec = (
18033 
    None, # 0
18034 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18035 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18036 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18037 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18038 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18039 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18040 
  )
18041 
 
18042 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18043 
    self.settlementDate = settlementDate
18044 
    self.paymentGatewayId = paymentGatewayId
18045 
    self.paymentId = paymentId
18046 
    self.serviceTax = serviceTax
18047 
    self.otherCharges = otherCharges
18048 
    self.netCollection = netCollection
18049 
 
18050 
  def read(self, iprot):
18051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18053 
      return
18054 
    iprot.readStructBegin()
18055 
    while True:
18056 
      (fname, ftype, fid) = iprot.readFieldBegin()
18057 
      if ftype == TType.STOP:
18058 
        break
18059 
      if fid == 1:
18060 
        if ftype == TType.I64:
18061 
          self.settlementDate = iprot.readI64();
18062 
        else:
18063 
          iprot.skip(ftype)
18064 
      elif fid == 2:
18065 
        if ftype == TType.I64:
18066 
          self.paymentGatewayId = iprot.readI64();
18067 
        else:
18068 
          iprot.skip(ftype)
18069 
      elif fid == 3:
18070 
        if ftype == TType.I64:
18071 
          self.paymentId = iprot.readI64();
18072 
        else:
18073 
          iprot.skip(ftype)
18074 
      elif fid == 4:
18075 
        if ftype == TType.DOUBLE:
18076 
          self.serviceTax = iprot.readDouble();
18077 
        else:
18078 
          iprot.skip(ftype)
18079 
      elif fid == 5:
18080 
        if ftype == TType.DOUBLE:
18081 
          self.otherCharges = iprot.readDouble();
18082 
        else:
18083 
          iprot.skip(ftype)
18084 
      elif fid == 6:
18085 
        if ftype == TType.DOUBLE:
18086 
          self.netCollection = iprot.readDouble();
18087 
        else:
18088 
          iprot.skip(ftype)
18089 
      else:
18090 
        iprot.skip(ftype)
18091 
      iprot.readFieldEnd()
18092 
    iprot.readStructEnd()
18093 
 
18094 
  def write(self, oprot):
18095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18097 
      return
18098 
    oprot.writeStructBegin('savePaymentSettlements_args')
18099 
    if self.settlementDate is not None:
18100 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18101 
      oprot.writeI64(self.settlementDate)
18102 
      oprot.writeFieldEnd()
18103 
    if self.paymentGatewayId is not None:
18104 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18105 
      oprot.writeI64(self.paymentGatewayId)
18106 
      oprot.writeFieldEnd()
18107 
    if self.paymentId is not None:
18108 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18109 
      oprot.writeI64(self.paymentId)
18110 
      oprot.writeFieldEnd()
18111 
    if self.serviceTax is not None:
18112 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18113 
      oprot.writeDouble(self.serviceTax)
18114 
      oprot.writeFieldEnd()
18115 
    if self.otherCharges is not None:
18116 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18117 
      oprot.writeDouble(self.otherCharges)
18118 
      oprot.writeFieldEnd()
18119 
    if self.netCollection is not None:
18120 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18121 
      oprot.writeDouble(self.netCollection)
18122 
      oprot.writeFieldEnd()
18123 
    oprot.writeFieldStop()
18124 
    oprot.writeStructEnd()
18125 
 
18126 
  def validate(self):
18127 
    return
18128 
 
18129 
 
18130 
  def __repr__(self):
18131 
    L = ['%s=%r' % (key, value)
18132 
      for key, value in self.__dict__.iteritems()]
18133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18134 
 
18135 
  def __eq__(self, other):
18136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18137 
 
18138 
  def __ne__(self, other):
18139 
    return not (self == other)
18140 
 
18141 
class savePaymentSettlements_result:
18142 
  """
18143 
  Attributes:
18144 
   - ex
18145 
  """
18146 
 
18147 
  thrift_spec = (
18148 
    None, # 0
18149 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18150 
  )
18151 
 
18152 
  def __init__(self, ex=None,):
18153 
    self.ex = ex
18154 
 
18155 
  def read(self, iprot):
18156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18158 
      return
18159 
    iprot.readStructBegin()
18160 
    while True:
18161 
      (fname, ftype, fid) = iprot.readFieldBegin()
18162 
      if ftype == TType.STOP:
18163 
        break
18164 
      if fid == 1:
18165 
        if ftype == TType.STRUCT:
18166 
          self.ex = TransactionServiceException()
18167 
          self.ex.read(iprot)
18168 
        else:
18169 
          iprot.skip(ftype)
18170 
      else:
18171 
        iprot.skip(ftype)
18172 
      iprot.readFieldEnd()
18173 
    iprot.readStructEnd()
18174 
 
18175 
  def write(self, oprot):
18176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18178 
      return
18179 
    oprot.writeStructBegin('savePaymentSettlements_result')
18180 
    if self.ex is not None:
18181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18182 
      self.ex.write(oprot)
18183 
      oprot.writeFieldEnd()
18184 
    oprot.writeFieldStop()
18185 
    oprot.writeStructEnd()
18186 
 
18187 
  def validate(self):
18188 
    return
18189 
 
18190 
 
18191 
  def __repr__(self):
18192 
    L = ['%s=%r' % (key, value)
18193 
      for key, value in self.__dict__.iteritems()]
18194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18195 
 
18196 
  def __eq__(self, other):
18197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18198 
 
18199 
  def __ne__(self, other):
18200 
    return not (self == other)
18201 
 
18202 
class saveEBSSettlementSummary_args:
18203 
  """
18204 
  Attributes:
18205 
   - settlementId
18206 
   - settlementDate
18207 
   - transactionDateFrom
18208 
   - transactionDateTo
18209 
   - amount
18210 
  """
18211 
 
18212 
  thrift_spec = (
18213 
    None, # 0
18214 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18215 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18216 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18217 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18218 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18219 
  )
18220 
 
18221 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18222 
    self.settlementId = settlementId
18223 
    self.settlementDate = settlementDate
18224 
    self.transactionDateFrom = transactionDateFrom
18225 
    self.transactionDateTo = transactionDateTo
18226 
    self.amount = amount
18227 
 
18228 
  def read(self, iprot):
18229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18231 
      return
18232 
    iprot.readStructBegin()
18233 
    while True:
18234 
      (fname, ftype, fid) = iprot.readFieldBegin()
18235 
      if ftype == TType.STOP:
18236 
        break
18237 
      if fid == 1:
18238 
        if ftype == TType.I64:
18239 
          self.settlementId = iprot.readI64();
18240 
        else:
18241 
          iprot.skip(ftype)
18242 
      elif fid == 2:
18243 
        if ftype == TType.I64:
18244 
          self.settlementDate = iprot.readI64();
18245 
        else:
18246 
          iprot.skip(ftype)
18247 
      elif fid == 3:
18248 
        if ftype == TType.I64:
18249 
          self.transactionDateFrom = iprot.readI64();
18250 
        else:
18251 
          iprot.skip(ftype)
18252 
      elif fid == 4:
18253 
        if ftype == TType.I64:
18254 
          self.transactionDateTo = iprot.readI64();
18255 
        else:
18256 
          iprot.skip(ftype)
18257 
      elif fid == 5:
18258 
        if ftype == TType.DOUBLE:
18259 
          self.amount = iprot.readDouble();
18260 
        else:
18261 
          iprot.skip(ftype)
18262 
      else:
18263 
        iprot.skip(ftype)
18264 
      iprot.readFieldEnd()
18265 
    iprot.readStructEnd()
18266 
 
18267 
  def write(self, oprot):
18268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18270 
      return
18271 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18272 
    if self.settlementId is not None:
18273 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18274 
      oprot.writeI64(self.settlementId)
18275 
      oprot.writeFieldEnd()
18276 
    if self.settlementDate is not None:
18277 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18278 
      oprot.writeI64(self.settlementDate)
18279 
      oprot.writeFieldEnd()
18280 
    if self.transactionDateFrom is not None:
18281 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18282 
      oprot.writeI64(self.transactionDateFrom)
18283 
      oprot.writeFieldEnd()
18284 
    if self.transactionDateTo is not None:
18285 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18286 
      oprot.writeI64(self.transactionDateTo)
18287 
      oprot.writeFieldEnd()
18288 
    if self.amount is not None:
18289 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18290 
      oprot.writeDouble(self.amount)
18291 
      oprot.writeFieldEnd()
18292 
    oprot.writeFieldStop()
18293 
    oprot.writeStructEnd()
18294 
 
18295 
  def validate(self):
18296 
    return
18297 
 
18298 
 
18299 
  def __repr__(self):
18300 
    L = ['%s=%r' % (key, value)
18301 
      for key, value in self.__dict__.iteritems()]
18302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18303 
 
18304 
  def __eq__(self, other):
18305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18306 
 
18307 
  def __ne__(self, other):
18308 
    return not (self == other)
18309 
 
18310 
class saveEBSSettlementSummary_result:
18311 
  """
18312 
  Attributes:
18313 
   - ex
18314 
  """
18315 
 
18316 
  thrift_spec = (
18317 
    None, # 0
18318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18319 
  )
18320 
 
18321 
  def __init__(self, ex=None,):
18322 
    self.ex = ex
18323 
 
18324 
  def read(self, iprot):
18325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18327 
      return
18328 
    iprot.readStructBegin()
18329 
    while True:
18330 
      (fname, ftype, fid) = iprot.readFieldBegin()
18331 
      if ftype == TType.STOP:
18332 
        break
18333 
      if fid == 1:
18334 
        if ftype == TType.STRUCT:
18335 
          self.ex = TransactionServiceException()
18336 
          self.ex.read(iprot)
18337 
        else:
18338 
          iprot.skip(ftype)
18339 
      else:
18340 
        iprot.skip(ftype)
18341 
      iprot.readFieldEnd()
18342 
    iprot.readStructEnd()
18343 
 
18344 
  def write(self, oprot):
18345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18347 
      return
18348 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18349 
    if self.ex is not None:
18350 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18351 
      self.ex.write(oprot)
18352 
      oprot.writeFieldEnd()
18353 
    oprot.writeFieldStop()
18354 
    oprot.writeStructEnd()
18355 
 
18356 
  def validate(self):
18357 
    return
18358 
 
18359 
 
18360 
  def __repr__(self):
18361 
    L = ['%s=%r' % (key, value)
18362 
      for key, value in self.__dict__.iteritems()]
18363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18364 
 
18365 
  def __eq__(self, other):
18366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18367 
 
18368 
  def __ne__(self, other):
18369 
    return not (self == other)
18370 
 
18371 
class getSettlementForPaymentId_args:
18372 
  """
18373 
  Attributes:
18374 
   - paymentId
18375 
  """
18376 
 
18377 
  thrift_spec = (
18378 
    None, # 0
18379 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18380 
  )
18381 
 
18382 
  def __init__(self, paymentId=None,):
18383 
    self.paymentId = paymentId
18384 
 
18385 
  def read(self, iprot):
18386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18388 
      return
18389 
    iprot.readStructBegin()
18390 
    while True:
18391 
      (fname, ftype, fid) = iprot.readFieldBegin()
18392 
      if ftype == TType.STOP:
18393 
        break
18394 
      if fid == 1:
18395 
        if ftype == TType.I64:
18396 
          self.paymentId = iprot.readI64();
18397 
        else:
18398 
          iprot.skip(ftype)
18399 
      else:
18400 
        iprot.skip(ftype)
18401 
      iprot.readFieldEnd()
18402 
    iprot.readStructEnd()
18403 
 
18404 
  def write(self, oprot):
18405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18407 
      return
18408 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18409 
    if self.paymentId is not None:
18410 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18411 
      oprot.writeI64(self.paymentId)
18412 
      oprot.writeFieldEnd()
18413 
    oprot.writeFieldStop()
18414 
    oprot.writeStructEnd()
18415 
 
18416 
  def validate(self):
18417 
    return
18418 
 
18419 
 
18420 
  def __repr__(self):
18421 
    L = ['%s=%r' % (key, value)
18422 
      for key, value in self.__dict__.iteritems()]
18423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18424 
 
18425 
  def __eq__(self, other):
18426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18427 
 
18428 
  def __ne__(self, other):
18429 
    return not (self == other)
18430 
 
18431 
class getSettlementForPaymentId_result:
18432 
  """
18433 
  Attributes:
18434 
   - success
18435 
   - ex
18436 
  """
18437 
 
18438 
  thrift_spec = (
18439 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18441 
  )
18442 
 
18443 
  def __init__(self, success=None, ex=None,):
18444 
    self.success = success
18445 
    self.ex = ex
18446 
 
18447 
  def read(self, iprot):
18448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18450 
      return
18451 
    iprot.readStructBegin()
18452 
    while True:
18453 
      (fname, ftype, fid) = iprot.readFieldBegin()
18454 
      if ftype == TType.STOP:
18455 
        break
18456 
      if fid == 0:
18457 
        if ftype == TType.STRUCT:
18458 
          self.success = PaymentSettlement()
18459 
          self.success.read(iprot)
18460 
        else:
18461 
          iprot.skip(ftype)
18462 
      elif fid == 1:
18463 
        if ftype == TType.STRUCT:
18464 
          self.ex = TransactionServiceException()
18465 
          self.ex.read(iprot)
18466 
        else:
18467 
          iprot.skip(ftype)
18468 
      else:
18469 
        iprot.skip(ftype)
18470 
      iprot.readFieldEnd()
18471 
    iprot.readStructEnd()
18472 
 
18473 
  def write(self, oprot):
18474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18476 
      return
18477 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18478 
    if self.success is not None:
18479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18480 
      self.success.write(oprot)
18481 
      oprot.writeFieldEnd()
18482 
    if self.ex is not None:
18483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18484 
      self.ex.write(oprot)
18485 
      oprot.writeFieldEnd()
18486 
    oprot.writeFieldStop()
18487 
    oprot.writeStructEnd()
18488 
 
18489 
  def validate(self):
18490 
    return
18491 
 
18492 
 
18493 
  def __repr__(self):
18494 
    L = ['%s=%r' % (key, value)
18495 
      for key, value in self.__dict__.iteritems()]
18496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18497 
 
18498 
  def __eq__(self, other):
18499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18500 
 
18501 
  def __ne__(self, other):
18502 
    return not (self == other)
18503 
 
18504 
class getEBSSettlementSummaries_args:
18505 
 
18506 
  thrift_spec = (
18507 
  )
18508 
 
18509 
  def read(self, iprot):
18510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18512 
      return
18513 
    iprot.readStructBegin()
18514 
    while True:
18515 
      (fname, ftype, fid) = iprot.readFieldBegin()
18516 
      if ftype == TType.STOP:
18517 
        break
18518 
      else:
18519 
        iprot.skip(ftype)
18520 
      iprot.readFieldEnd()
18521 
    iprot.readStructEnd()
18522 
 
18523 
  def write(self, oprot):
18524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18526 
      return
18527 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18528 
    oprot.writeFieldStop()
18529 
    oprot.writeStructEnd()
18530 
 
18531 
  def validate(self):
18532 
    return
18533 
 
18534 
 
18535 
  def __repr__(self):
18536 
    L = ['%s=%r' % (key, value)
18537 
      for key, value in self.__dict__.iteritems()]
18538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18539 
 
18540 
  def __eq__(self, other):
18541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18542 
 
18543 
  def __ne__(self, other):
18544 
    return not (self == other)
18545 
 
18546 
class getEBSSettlementSummaries_result:
18547 
  """
18548 
  Attributes:
18549 
   - success
18550 
   - ex
18551 
  """
18552 
 
18553 
  thrift_spec = (
18554 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18555 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18556 
  )
18557 
 
18558 
  def __init__(self, success=None, ex=None,):
18559 
    self.success = success
18560 
    self.ex = ex
18561 
 
18562 
  def read(self, iprot):
18563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18565 
      return
18566 
    iprot.readStructBegin()
18567 
    while True:
18568 
      (fname, ftype, fid) = iprot.readFieldBegin()
18569 
      if ftype == TType.STOP:
18570 
        break
18571 
      if fid == 0:
18572 
        if ftype == TType.MAP:
18573 
          self.success = {}
4709 rajveer 18574 
          (_ktype322, _vtype323, _size321 ) = iprot.readMapBegin()
18575 
          for _i325 in xrange(_size321):
18576 
            _key326 = iprot.readI64();
18577 
            _val327 = iprot.readString();
18578 
            self.success[_key326] = _val327
4600 varun.gupt 18579 
          iprot.readMapEnd()
18580 
        else:
18581 
          iprot.skip(ftype)
18582 
      elif fid == 1:
18583 
        if ftype == TType.STRUCT:
18584 
          self.ex = TransactionServiceException()
18585 
          self.ex.read(iprot)
18586 
        else:
18587 
          iprot.skip(ftype)
18588 
      else:
18589 
        iprot.skip(ftype)
18590 
      iprot.readFieldEnd()
18591 
    iprot.readStructEnd()
18592 
 
18593 
  def write(self, oprot):
18594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18596 
      return
18597 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18598 
    if self.success is not None:
18599 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18600 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4709 rajveer 18601 
      for kiter328,viter329 in self.success.items():
18602 
        oprot.writeI64(kiter328)
18603 
        oprot.writeString(viter329)
4600 varun.gupt 18604 
      oprot.writeMapEnd()
18605 
      oprot.writeFieldEnd()
18606 
    if self.ex is not None:
18607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18608 
      self.ex.write(oprot)
18609 
      oprot.writeFieldEnd()
18610 
    oprot.writeFieldStop()
18611 
    oprot.writeStructEnd()
18612 
 
18613 
  def validate(self):
18614 
    return
18615 
 
18616 
 
18617 
  def __repr__(self):
18618 
    L = ['%s=%r' % (key, value)
18619 
      for key, value in self.__dict__.iteritems()]
18620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18621 
 
18622 
  def __eq__(self, other):
18623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18624 
 
18625 
  def __ne__(self, other):
18626 
    return not (self == other)
18627 
 
18628 
class markEBSSettlementUploaded_args:
18629 
  """
18630 
  Attributes:
18631 
   - settlementId
18632 
  """
18633 
 
18634 
  thrift_spec = (
18635 
    None, # 0
18636 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18637 
  )
18638 
 
18639 
  def __init__(self, settlementId=None,):
18640 
    self.settlementId = settlementId
18641 
 
18642 
  def read(self, iprot):
18643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18645 
      return
18646 
    iprot.readStructBegin()
18647 
    while True:
18648 
      (fname, ftype, fid) = iprot.readFieldBegin()
18649 
      if ftype == TType.STOP:
18650 
        break
18651 
      if fid == 1:
18652 
        if ftype == TType.I64:
18653 
          self.settlementId = iprot.readI64();
18654 
        else:
18655 
          iprot.skip(ftype)
18656 
      else:
18657 
        iprot.skip(ftype)
18658 
      iprot.readFieldEnd()
18659 
    iprot.readStructEnd()
18660 
 
18661 
  def write(self, oprot):
18662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18664 
      return
18665 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18666 
    if self.settlementId is not None:
18667 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18668 
      oprot.writeI64(self.settlementId)
18669 
      oprot.writeFieldEnd()
18670 
    oprot.writeFieldStop()
18671 
    oprot.writeStructEnd()
18672 
 
18673 
  def validate(self):
18674 
    return
18675 
 
18676 
 
18677 
  def __repr__(self):
18678 
    L = ['%s=%r' % (key, value)
18679 
      for key, value in self.__dict__.iteritems()]
18680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18681 
 
18682 
  def __eq__(self, other):
18683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18684 
 
18685 
  def __ne__(self, other):
18686 
    return not (self == other)
18687 
 
18688 
class markEBSSettlementUploaded_result:
18689 
  """
18690 
  Attributes:
18691 
   - ex
18692 
  """
18693 
 
18694 
  thrift_spec = (
18695 
    None, # 0
18696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18697 
  )
18698 
 
18699 
  def __init__(self, ex=None,):
18700 
    self.ex = ex
18701 
 
18702 
  def read(self, iprot):
18703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18705 
      return
18706 
    iprot.readStructBegin()
18707 
    while True:
18708 
      (fname, ftype, fid) = iprot.readFieldBegin()
18709 
      if ftype == TType.STOP:
18710 
        break
18711 
      if fid == 1:
18712 
        if ftype == TType.STRUCT:
18713 
          self.ex = TransactionServiceException()
18714 
          self.ex.read(iprot)
18715 
        else:
18716 
          iprot.skip(ftype)
18717 
      else:
18718 
        iprot.skip(ftype)
18719 
      iprot.readFieldEnd()
18720 
    iprot.readStructEnd()
18721 
 
18722 
  def write(self, oprot):
18723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18725 
      return
18726 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18727 
    if self.ex is not None:
18728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18729 
      self.ex.write(oprot)
18730 
      oprot.writeFieldEnd()
18731 
    oprot.writeFieldStop()
18732 
    oprot.writeStructEnd()
18733 
 
18734 
  def validate(self):
18735 
    return
18736 
 
18737 
 
18738 
  def __repr__(self):
18739 
    L = ['%s=%r' % (key, value)
18740 
      for key, value in self.__dict__.iteritems()]
18741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18742 
 
18743 
  def __eq__(self, other):
18744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18745 
 
18746 
  def __ne__(self, other):
18747 
    return not (self == other)
18748 
 
18749 
class getEBSSettlementDate_args:
18750 
  """
18751 
  Attributes:
18752 
   - settlementId
18753 
  """
18754 
 
18755 
  thrift_spec = (
18756 
    None, # 0
18757 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18758 
  )
18759 
 
18760 
  def __init__(self, settlementId=None,):
18761 
    self.settlementId = settlementId
18762 
 
18763 
  def read(self, iprot):
18764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18766 
      return
18767 
    iprot.readStructBegin()
18768 
    while True:
18769 
      (fname, ftype, fid) = iprot.readFieldBegin()
18770 
      if ftype == TType.STOP:
18771 
        break
18772 
      if fid == 1:
18773 
        if ftype == TType.I64:
18774 
          self.settlementId = iprot.readI64();
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      else:
18778 
        iprot.skip(ftype)
18779 
      iprot.readFieldEnd()
18780 
    iprot.readStructEnd()
18781 
 
18782 
  def write(self, oprot):
18783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18785 
      return
18786 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18787 
    if self.settlementId is not None:
18788 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18789 
      oprot.writeI64(self.settlementId)
18790 
      oprot.writeFieldEnd()
18791 
    oprot.writeFieldStop()
18792 
    oprot.writeStructEnd()
18793 
 
18794 
  def validate(self):
18795 
    return
18796 
 
18797 
 
18798 
  def __repr__(self):
18799 
    L = ['%s=%r' % (key, value)
18800 
      for key, value in self.__dict__.iteritems()]
18801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18802 
 
18803 
  def __eq__(self, other):
18804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18805 
 
18806 
  def __ne__(self, other):
18807 
    return not (self == other)
18808 
 
18809 
class getEBSSettlementDate_result:
18810 
  """
18811 
  Attributes:
18812 
   - success
18813 
   - ex
18814 
  """
18815 
 
18816 
  thrift_spec = (
18817 
    (0, TType.I64, 'success', None, None, ), # 0
18818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18819 
  )
18820 
 
18821 
  def __init__(self, success=None, ex=None,):
18822 
    self.success = success
18823 
    self.ex = ex
18824 
 
18825 
  def read(self, iprot):
18826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18828 
      return
18829 
    iprot.readStructBegin()
18830 
    while True:
18831 
      (fname, ftype, fid) = iprot.readFieldBegin()
18832 
      if ftype == TType.STOP:
18833 
        break
18834 
      if fid == 0:
18835 
        if ftype == TType.I64:
18836 
          self.success = iprot.readI64();
18837 
        else:
18838 
          iprot.skip(ftype)
18839 
      elif fid == 1:
18840 
        if ftype == TType.STRUCT:
18841 
          self.ex = TransactionServiceException()
18842 
          self.ex.read(iprot)
18843 
        else:
18844 
          iprot.skip(ftype)
18845 
      else:
18846 
        iprot.skip(ftype)
18847 
      iprot.readFieldEnd()
18848 
    iprot.readStructEnd()
18849 
 
18850 
  def write(self, oprot):
18851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18853 
      return
18854 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18855 
    if self.success is not None:
18856 
      oprot.writeFieldBegin('success', TType.I64, 0)
18857 
      oprot.writeI64(self.success)
18858 
      oprot.writeFieldEnd()
18859 
    if self.ex is not None:
18860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18861 
      self.ex.write(oprot)
18862 
      oprot.writeFieldEnd()
18863 
    oprot.writeFieldStop()
18864 
    oprot.writeStructEnd()
18865 
 
18866 
  def validate(self):
18867 
    return
18868 
 
18869 
 
18870 
  def __repr__(self):
18871 
    L = ['%s=%r' % (key, value)
18872 
      for key, value in self.__dict__.iteritems()]
18873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18874 
 
18875 
  def __eq__(self, other):
18876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18877 
 
18878 
  def __ne__(self, other):
18879 
    return not (self == other)