Subversion Repositories SmartDukaan

Rev

Rev 4607 | Rev 4658 | 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 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
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
3064 chandransh 330 
     - imeiNumber
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 
 
4454 rajveer 443 
  def markOrderDoaRequestReceived(self, orderId):
444 
    """
445 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
446 
 
447 
    Parameters:
448 
     - orderId
449 
    """
450 
    pass
451 
 
452 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
453 
    """
454 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
455 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
456 
 
457 
    Parameters:
458 
     - orderId
459 
     - isAuthorized
460 
    """
461 
    pass
462 
 
4488 rajveer 463 
  def markOrderReturnRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
475 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4579 rajveer 483 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 484 
    """
485 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 486 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
487 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 488 
    For any other status, it returns false.
489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2536 chandransh 491 
    Parameters:
492 
     - orderId
4579 rajveer 493 
     - providerId
2536 chandransh 494 
    """
495 
    pass
496 
 
4602 rajveer 497 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 498 
    """
4452 rajveer 499 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 500 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
501 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
502 
    	3. Returns true
2591 chandransh 503 
    If the order is in any other status, it returns false.
2536 chandransh 504 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 505 
 
2536 chandransh 506 
    Parameters:
507 
     - orderId
508 
     - pickupNumber
4602 rajveer 509 
     - providerId
2536 chandransh 510 
    """
511 
    pass
512 
 
2764 chandransh 513 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
514 
    """
515 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
516 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 517 
 
2764 chandransh 518 
    Parameters:
519 
     - providerId
520 
     - pickupDetails
521 
    """
522 
    pass
523 
 
4479 rajveer 524 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 525 
    """
4452 rajveer 526 
    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 527 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 528 
    If the order is in any other state, it returns false.
529 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 530 
 
2591 chandransh 531 
    Parameters:
532 
     - orderId
4479 rajveer 533 
     - receiveCondition
2591 chandransh 534 
    """
535 
    pass
2536 chandransh 536 
 
2591 chandransh 537 
  def validateDoa(self, orderId, isValid):
538 
    """
4452 rajveer 539 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 540 
    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 541 
    If the order is in any other state, it returns false.
542 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 543 
 
2591 chandransh 544 
    Parameters:
545 
     - orderId
546 
     - isValid
547 
    """
548 
    pass
549 
 
4495 rajveer 550 
  def validateReturnProduct(self, orderId, isUsable):
551 
    """
552 
    Parameters:
553 
     - orderId
554 
     - isUsable
555 
    """
556 
    pass
557 
 
2616 chandransh 558 
  def reshipOrder(self, orderId):
559 
    """
4484 rajveer 560 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 561 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 562 
    	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 563 
 
564 
    If the order is in DOA_CERT_VALID state, it does the following:
565 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
566 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 567 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 568 
 
2616 chandransh 569 
    Returns the id of the newly created order.
3431 rajveer 570 
 
2616 chandransh 571 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 572 
 
2616 chandransh 573 
    Parameters:
574 
     - orderId
575 
    """
576 
    pass
2591 chandransh 577 
 
3226 chandransh 578 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 579 
    """
4484 rajveer 580 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 581 
    	1. Creates a refund request for batch processing.
582 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 583 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 584 
 
2616 chandransh 585 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
586 
    	1. Creates a refund request for batch processing.
3226 chandransh 587 
    	2. Cancels the reservation of the item in the warehouse.
588 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 589 
 
3226 chandransh 590 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
591 
    	1. Cancels the reservation of the item in the warehouse.
592 
    	2. Marks the current order as CANCELED.
593 
 
594 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
595 
 
2616 chandransh 596 
    Returns True if it is successful, False otherwise.
3431 rajveer 597 
 
2616 chandransh 598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2616 chandransh 600 
    Parameters:
601 
     - orderId
3226 chandransh 602 
     - refundedBy
603 
     - reason
2616 chandransh 604 
    """
605 
    pass
606 
 
2690 chandransh 607 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
608 
    """
609 
    Get all return orders created between the from and to dates for the given warehouse.
610 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 611 
 
2690 chandransh 612 
    Parameters:
613 
     - warehouseId
614 
     - fromDate
615 
     - toDate
616 
    """
617 
    pass
2616 chandransh 618 
 
2700 chandransh 619 
  def getReturnOrder(self, id):
620 
    """
621 
    Returns the ReturnOrder corresponding to the given id.
622 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 623 
 
2700 chandransh 624 
    Parameters:
625 
     - id
626 
    """
627 
    pass
628 
 
2690 chandransh 629 
  def processReturn(self, returnOrderId):
630 
    """
631 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 632 
 
2690 chandransh 633 
    Parameters:
634 
     - returnOrderId
635 
    """
636 
    pass
637 
 
2819 chandransh 638 
  def createPurchaseOrder(self, warehouseId):
639 
    """
4586 mandeep.dh 640 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
641 
    Returns the list of PO no. of the newly created purchase order.
642 
    Returns null if no new purchase order had to be created.
3431 rajveer 643 
 
2819 chandransh 644 
    Parameters:
645 
     - warehouseId
646 
    """
647 
    pass
2690 chandransh 648 
 
3451 chandransh 649 
  def updateWeight(self, orderId, weight):
650 
    """
651 
    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 652 
 
3451 chandransh 653 
    Parameters:
654 
     - orderId
655 
     - weight
656 
    """
657 
    pass
658 
 
3469 chandransh 659 
  def changeItem(self, orderId, itemId):
660 
    """
661 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
662 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 663 
 
3469 chandransh 664 
    Parameters:
665 
     - orderId
666 
     - itemId
667 
    """
668 
    pass
669 
 
670 
  def shiftToWarehouse(self, orderId, warehouseId):
671 
    """
672 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
673 
 
674 
    Parameters:
675 
     - orderId
676 
     - warehouseId
677 
    """
678 
    pass
679 
 
4647 rajveer 680 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 681 
    """
682 
    Adds the given delay reason to the given order.
3986 chandransh 683 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 684 
    Raises an exception if no order with the given id can be found.
3469 chandransh 685 
 
3553 chandransh 686 
    Parameters:
687 
     - orderId
688 
     - delayReason
3986 chandransh 689 
     - furtherDelay
4647 rajveer 690 
     - delayReasonText
3553 chandransh 691 
    """
692 
    pass
693 
 
3956 chandransh 694 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
695 
    """
696 
    Marks the COD orders with given AWB nos. as having been processed.
697 
    Updates the captured amount for the corresponding payment.
3553 chandransh 698 
 
3956 chandransh 699 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
700 
    1. There is no order corresponding to an AWB number.
701 
    2. The captured amount for a payment exceeds the total payment.
702 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
703 
 
704 
    Parameters:
705 
     - collectedAmountMap
706 
     - xferBy
707 
     - xferTxnId
708 
     - xferDate
709 
    """
710 
    pass
711 
 
4008 mandeep.dh 712 
  def getTransactionsRequiringExtraProcessing(self, category):
713 
    """
4065 mandeep.dh 714 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 715 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 716 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 717 
 
4008 mandeep.dh 718 
    Parameters:
719 
     - category
720 
    """
721 
    pass
722 
 
723 
  def markTransactionAsProcessed(self, transactionId, category):
724 
    """
725 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 726 
    It essentially deletes the transaction id record for a particular
727 
    processing type category (if present) from DB.
728 
    This is currently used by CRM application.
4008 mandeep.dh 729 
 
730 
    Parameters:
731 
     - transactionId
732 
     - category
733 
    """
734 
    pass
735 
 
4018 chandransh 736 
  def getItemWiseRiskyOrdersCount(self, ):
737 
    """
738 
    Returns a map containing the number of risky orders keyed by item id. A risky order
739 
    is defined as one whose shipping date is about to expire.
740 
    """
741 
    pass
4008 mandeep.dh 742 
 
4295 varun.gupt 743 
  def getOrdersForItemIds(self, itemIds):
744 
    """
745 
    Returns a list of all orders which have items with given id
746 
 
747 
    Parameters:
748 
     - itemIds
749 
    """
750 
    pass
751 
 
4247 rajveer 752 
  def markOrderCancellationRequestReceived(self, orderId):
753 
    """
754 
    Mark order as cancellation request received. If customer sends request of cancellation of
755 
    a particular order, this method will be called. It will just change status of the order
756 
    depending on its current status. It also records the previous status, so that we can move
757 
    back to that status if cancellation request is denied.
4018 chandransh 758 
 
4247 rajveer 759 
    Parameters:
760 
     - orderId
761 
    """
762 
    pass
763 
 
764 
  def markOrderCancellationRequestConfirmed(self, orderId):
765 
    """
766 
    If we decide to to cancel order, CRM will call this method to move the status of order to
767 
    cancellation request confirmed. After this OM will be able to cancel the order.
768 
 
769 
    Parameters:
770 
     - orderId
771 
    """
772 
    pass
773 
 
774 
  def markOrderCancellationRequestDenied(self, orderId):
775 
    """
776 
    If we decide to not to cancel order, we will move the order ro previous status.
777 
 
778 
    Parameters:
779 
     - orderId
780 
    """
781 
    pass
782 
 
4258 rajveer 783 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 784 
    """
4258 rajveer 785 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
786 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 787 
 
788 
    Parameters:
4258 rajveer 789 
     - transactionId
4247 rajveer 790 
    """
791 
    pass
792 
 
4259 anupam.sin 793 
  def refundTransaction(self, transactionId, refundedBy, reason):
794 
    """
795 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
796 
    need to be cancelled
4247 rajveer 797 
 
4259 anupam.sin 798 
    Parameters:
799 
     - transactionId
800 
     - refundedBy
801 
     - reason
802 
    """
803 
    pass
804 
 
4324 mandeep.dh 805 
  def updateShipmentAddress(self, orderId, addressId):
806 
    """
807 
    Updates shipment address of an order. Delivery and shipping date estimates
808 
    etc. are also updated here.
809 
 
810 
    Throws TransactionServiceException in case address change is not
811 
    possible due to certain reasons such as new pincode in address is
812 
    not serviceable etc.
813 
 
814 
    Parameters:
815 
     - orderId
816 
     - addressId
817 
    """
818 
    pass
819 
 
4285 rajveer 820 
  def acceptOrdersForItemId(self, itemId, inventory):
821 
    """
822 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
823 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 824 
 
4285 rajveer 825 
    Parameters:
826 
     - itemId
827 
     - inventory
828 
    """
829 
    pass
830 
 
4369 rajveer 831 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 832 
    """
833 
    Parameters:
834 
     - vendorId
835 
     - itemId
836 
     - quantity
837 
     - estimate
4369 rajveer 838 
     - isReminder
4303 rajveer 839 
    """
840 
    pass
4285 rajveer 841 
 
4369 rajveer 842 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 843 
    """
844 
    Parameters:
845 
     - vendorId
846 
     - itemId
847 
     - quantity
848 
     - estimate
4369 rajveer 849 
     - isReminder
4303 rajveer 850 
    """
851 
    pass
852 
 
4369 rajveer 853 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 854 
    """
855 
    Parameters:
856 
     - vendorId
857 
     - itemId
858 
     - quantity
859 
     - estimate
4369 rajveer 860 
     - isReminder
4303 rajveer 861 
    """
862 
    pass
863 
 
4369 rajveer 864 
  def markOrdersAsTimeout(self, vendorId):
865 
    """
866 
    Parameters:
867 
     - vendorId
868 
    """
869 
    pass
4303 rajveer 870 
 
4386 anupam.sin 871 
  def getOrderForAwb(self, awb):
872 
    """
873 
    Returns the order corresponding to an AWB number
4369 rajveer 874 
 
4386 anupam.sin 875 
    Parameters:
876 
     - awb
877 
    """
878 
    pass
879 
 
4506 phani.kuma 880 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
881 
    """
882 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 883 
 
4506 phani.kuma 884 
    Parameters:
885 
     - logistics_provider_id
886 
     - order_status
887 
    """
888 
    pass
889 
 
4600 varun.gupt 890 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
891 
    """
892 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 893 
 
4600 varun.gupt 894 
    Parameters:
895 
     - vendorId
896 
     - billingDateFrom
897 
     - billingDateTo
898 
    """
899 
    pass
900 
 
4607 rajveer 901 
  def getSlippedSippingDateOrders(self, ):
902 
    pass
903 
 
4600 varun.gupt 904 
  def saveBluedartSettlements(self, mapAWBAndAmount):
905 
    """
906 
    Parameters:
907 
     - mapAWBAndAmount
908 
    """
909 
    pass
910 
 
911 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
912 
    """
913 
    Parameters:
914 
     - settlementDate
915 
     - paymentGatewayId
916 
     - paymentId
917 
     - serviceTax
918 
     - otherCharges
919 
     - netCollection
920 
    """
921 
    pass
922 
 
923 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
924 
    """
925 
    Parameters:
926 
     - settlementId
927 
     - settlementDate
928 
     - transactionDateFrom
929 
     - transactionDateTo
930 
     - amount
931 
    """
932 
    pass
933 
 
934 
  def getSettlementForPaymentId(self, paymentId):
935 
    """
936 
    Parameters:
937 
     - paymentId
938 
    """
939 
    pass
940 
 
941 
  def getEBSSettlementSummaries(self, ):
942 
    pass
943 
 
944 
  def markEBSSettlementUploaded(self, settlementId):
945 
    """
946 
    Parameters:
947 
     - settlementId
948 
    """
949 
    pass
950 
 
951 
  def getEBSSettlementDate(self, settlementId):
952 
    """
953 
    Parameters:
954 
     - settlementId
955 
    """
956 
    pass
957 
 
958 
 
3376 rajveer 959 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 960 
  def __init__(self, iprot, oprot=None):
3376 rajveer 961 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 962 
 
963 
  def createTransaction(self, transaction):
964 
    """
965 
    Parameters:
966 
     - transaction
967 
    """
968 
    self.send_createTransaction(transaction)
132 ashish 969 
    return self.recv_createTransaction()
94 ashish 970 
 
971 
  def send_createTransaction(self, transaction):
972 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
973 
    args = createTransaction_args()
974 
    args.transaction = transaction
975 
    args.write(self._oprot)
976 
    self._oprot.writeMessageEnd()
977 
    self._oprot.trans.flush()
978 
 
979 
  def recv_createTransaction(self, ):
980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
981 
    if mtype == TMessageType.EXCEPTION:
982 
      x = TApplicationException()
983 
      x.read(self._iprot)
984 
      self._iprot.readMessageEnd()
985 
      raise x
986 
    result = createTransaction_result()
987 
    result.read(self._iprot)
988 
    self._iprot.readMessageEnd()
3431 rajveer 989 
    if result.success is not None:
132 ashish 990 
      return result.success
3431 rajveer 991 
    if result.ex is not None:
94 ashish 992 
      raise result.ex
132 ashish 993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 994 
 
995 
  def getTransaction(self, id):
996 
    """
997 
    Parameters:
998 
     - id
999 
    """
1000 
    self.send_getTransaction(id)
1001 
    return self.recv_getTransaction()
1002 
 
1003 
  def send_getTransaction(self, id):
1004 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1005 
    args = getTransaction_args()
1006 
    args.id = id
1007 
    args.write(self._oprot)
1008 
    self._oprot.writeMessageEnd()
1009 
    self._oprot.trans.flush()
1010 
 
1011 
  def recv_getTransaction(self, ):
1012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1013 
    if mtype == TMessageType.EXCEPTION:
1014 
      x = TApplicationException()
1015 
      x.read(self._iprot)
1016 
      self._iprot.readMessageEnd()
1017 
      raise x
1018 
    result = getTransaction_result()
1019 
    result.read(self._iprot)
1020 
    self._iprot.readMessageEnd()
3431 rajveer 1021 
    if result.success is not None:
94 ashish 1022 
      return result.success
3431 rajveer 1023 
    if result.ex is not None:
94 ashish 1024 
      raise result.ex
1025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1026 
 
1027 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1028 
    """
1029 
    Parameters:
1030 
     - customerId
1031 
     - from_date
1032 
     - to_date
1033 
     - status
1034 
    """
1035 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1036 
    return self.recv_getTransactionsForCustomer()
1037 
 
1038 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1039 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1040 
    args = getTransactionsForCustomer_args()
1041 
    args.customerId = customerId
1042 
    args.from_date = from_date
1043 
    args.to_date = to_date
1044 
    args.status = status
1045 
    args.write(self._oprot)
1046 
    self._oprot.writeMessageEnd()
1047 
    self._oprot.trans.flush()
1048 
 
1049 
  def recv_getTransactionsForCustomer(self, ):
1050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1051 
    if mtype == TMessageType.EXCEPTION:
1052 
      x = TApplicationException()
1053 
      x.read(self._iprot)
1054 
      self._iprot.readMessageEnd()
1055 
      raise x
1056 
    result = getTransactionsForCustomer_result()
1057 
    result.read(self._iprot)
1058 
    self._iprot.readMessageEnd()
3431 rajveer 1059 
    if result.success is not None:
94 ashish 1060 
      return result.success
3431 rajveer 1061 
    if result.ex is not None:
94 ashish 1062 
      raise result.ex
1063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1064 
 
132 ashish 1065 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1066 
    """
1067 
    Parameters:
1068 
     - shoppingCartId
1069 
    """
1070 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1071 
    return self.recv_getTransactionsForShoppingCartId()
1072 
 
1073 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1074 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1075 
    args = getTransactionsForShoppingCartId_args()
1076 
    args.shoppingCartId = shoppingCartId
1077 
    args.write(self._oprot)
1078 
    self._oprot.writeMessageEnd()
1079 
    self._oprot.trans.flush()
1080 
 
1081 
  def recv_getTransactionsForShoppingCartId(self, ):
1082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1083 
    if mtype == TMessageType.EXCEPTION:
1084 
      x = TApplicationException()
1085 
      x.read(self._iprot)
1086 
      self._iprot.readMessageEnd()
1087 
      raise x
1088 
    result = getTransactionsForShoppingCartId_result()
1089 
    result.read(self._iprot)
1090 
    self._iprot.readMessageEnd()
3431 rajveer 1091 
    if result.success is not None:
132 ashish 1092 
      return result.success
3431 rajveer 1093 
    if result.ex is not None:
132 ashish 1094 
      raise result.ex
1095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1096 
 
94 ashish 1097 
  def getTransactionStatus(self, transactionId):
1098 
    """
1099 
    Parameters:
1100 
     - transactionId
1101 
    """
1102 
    self.send_getTransactionStatus(transactionId)
1103 
    return self.recv_getTransactionStatus()
1104 
 
1105 
  def send_getTransactionStatus(self, transactionId):
1106 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1107 
    args = getTransactionStatus_args()
1108 
    args.transactionId = transactionId
1109 
    args.write(self._oprot)
1110 
    self._oprot.writeMessageEnd()
1111 
    self._oprot.trans.flush()
1112 
 
1113 
  def recv_getTransactionStatus(self, ):
1114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1115 
    if mtype == TMessageType.EXCEPTION:
1116 
      x = TApplicationException()
1117 
      x.read(self._iprot)
1118 
      self._iprot.readMessageEnd()
1119 
      raise x
1120 
    result = getTransactionStatus_result()
1121 
    result.read(self._iprot)
1122 
    self._iprot.readMessageEnd()
3431 rajveer 1123 
    if result.success is not None:
94 ashish 1124 
      return result.success
3431 rajveer 1125 
    if result.ex is not None:
94 ashish 1126 
      raise result.ex
1127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1128 
 
1129 
  def changeTransactionStatus(self, transactionId, status, description):
1130 
    """
1131 
    Parameters:
1132 
     - transactionId
1133 
     - status
1134 
     - description
1135 
    """
1136 
    self.send_changeTransactionStatus(transactionId, status, description)
1137 
    return self.recv_changeTransactionStatus()
1138 
 
1139 
  def send_changeTransactionStatus(self, transactionId, status, description):
1140 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1141 
    args = changeTransactionStatus_args()
1142 
    args.transactionId = transactionId
1143 
    args.status = status
1144 
    args.description = description
1145 
    args.write(self._oprot)
1146 
    self._oprot.writeMessageEnd()
1147 
    self._oprot.trans.flush()
1148 
 
1149 
  def recv_changeTransactionStatus(self, ):
1150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1151 
    if mtype == TMessageType.EXCEPTION:
1152 
      x = TApplicationException()
1153 
      x.read(self._iprot)
1154 
      self._iprot.readMessageEnd()
1155 
      raise x
1156 
    result = changeTransactionStatus_result()
1157 
    result.read(self._iprot)
1158 
    self._iprot.readMessageEnd()
3431 rajveer 1159 
    if result.success is not None:
94 ashish 1160 
      return result.success
3431 rajveer 1161 
    if result.ex is not None:
94 ashish 1162 
      raise result.ex
1163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1164 
 
1398 varun.gupt 1165 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1166 
    """
1167 
    Parameters:
1168 
     - transactionId
1169 
    """
1398 varun.gupt 1170 
    self.send_enqueueTransactionInfoEmail(transactionId)
1171 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1172 
 
1398 varun.gupt 1173 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1174 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1175 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1176 
    args.transactionId = transactionId
1177 
    args.write(self._oprot)
1178 
    self._oprot.writeMessageEnd()
1179 
    self._oprot.trans.flush()
1180 
 
1398 varun.gupt 1181 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1183 
    if mtype == TMessageType.EXCEPTION:
1184 
      x = TApplicationException()
1185 
      x.read(self._iprot)
1186 
      self._iprot.readMessageEnd()
1187 
      raise x
1398 varun.gupt 1188 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1189 
    result.read(self._iprot)
1190 
    self._iprot.readMessageEnd()
3431 rajveer 1191 
    if result.success is not None:
1382 varun.gupt 1192 
      return result.success
3431 rajveer 1193 
    if result.ex is not None:
1382 varun.gupt 1194 
      raise result.ex
1398 varun.gupt 1195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1196 
 
483 rajveer 1197 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1198 
    """
1199 
    Parameters:
483 rajveer 1200 
     - status
1201 
     - from_date
1202 
     - to_date
1203 
     - warehouse_id
94 ashish 1204 
    """
483 rajveer 1205 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1206 
    return self.recv_getAllOrders()
94 ashish 1207 
 
483 rajveer 1208 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1209 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1210 
    args = getAllOrders_args()
1211 
    args.status = status
1212 
    args.from_date = from_date
1213 
    args.to_date = to_date
1214 
    args.warehouse_id = warehouse_id
94 ashish 1215 
    args.write(self._oprot)
1216 
    self._oprot.writeMessageEnd()
1217 
    self._oprot.trans.flush()
1218 
 
483 rajveer 1219 
  def recv_getAllOrders(self, ):
94 ashish 1220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1221 
    if mtype == TMessageType.EXCEPTION:
1222 
      x = TApplicationException()
1223 
      x.read(self._iprot)
1224 
      self._iprot.readMessageEnd()
1225 
      raise x
483 rajveer 1226 
    result = getAllOrders_result()
94 ashish 1227 
    result.read(self._iprot)
1228 
    self._iprot.readMessageEnd()
3431 rajveer 1229 
    if result.success is not None:
94 ashish 1230 
      return result.success
3431 rajveer 1231 
    if result.ex is not None:
94 ashish 1232 
      raise result.ex
483 rajveer 1233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1234 
 
4133 chandransh 1235 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1236 
    """
1237 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1238 
    Pass the status as null and the limit as 0 to ignore them.
1239 
 
1240 
    Parameters:
1241 
     - statuses
1242 
     - offset
1243 
     - limit
1244 
     - warehouse_id
1245 
    """
1246 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1247 
    return self.recv_getOrdersInBatch()
1248 
 
1249 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1250 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1251 
    args = getOrdersInBatch_args()
1252 
    args.statuses = statuses
1253 
    args.offset = offset
1254 
    args.limit = limit
1255 
    args.warehouse_id = warehouse_id
1256 
    args.write(self._oprot)
1257 
    self._oprot.writeMessageEnd()
1258 
    self._oprot.trans.flush()
1259 
 
1260 
  def recv_getOrdersInBatch(self, ):
1261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1262 
    if mtype == TMessageType.EXCEPTION:
1263 
      x = TApplicationException()
1264 
      x.read(self._iprot)
1265 
      self._iprot.readMessageEnd()
1266 
      raise x
1267 
    result = getOrdersInBatch_result()
1268 
    result.read(self._iprot)
1269 
    self._iprot.readMessageEnd()
1270 
    if result.success is not None:
1271 
      return result.success
1272 
    if result.ex is not None:
1273 
      raise result.ex
1274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1275 
 
1276 
  def getOrderCount(self, statuses, warehouseId):
1277 
    """
1278 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1279 
 
1280 
    Parameters:
1281 
     - statuses
1282 
     - warehouseId
1283 
    """
1284 
    self.send_getOrderCount(statuses, warehouseId)
1285 
    return self.recv_getOrderCount()
1286 
 
1287 
  def send_getOrderCount(self, statuses, warehouseId):
1288 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1289 
    args = getOrderCount_args()
1290 
    args.statuses = statuses
1291 
    args.warehouseId = warehouseId
1292 
    args.write(self._oprot)
1293 
    self._oprot.writeMessageEnd()
1294 
    self._oprot.trans.flush()
1295 
 
1296 
  def recv_getOrderCount(self, ):
1297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1298 
    if mtype == TMessageType.EXCEPTION:
1299 
      x = TApplicationException()
1300 
      x.read(self._iprot)
1301 
      self._iprot.readMessageEnd()
1302 
      raise x
1303 
    result = getOrderCount_result()
1304 
    result.read(self._iprot)
1305 
    self._iprot.readMessageEnd()
1306 
    if result.success is not None:
1307 
      return result.success
1308 
    if result.ex is not None:
1309 
      raise result.ex
1310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1311 
 
999 varun.gupt 1312 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1313 
    """
1132 chandransh 1314 
    Returns orders within a range of their billing dates
3431 rajveer 1315 
 
999 varun.gupt 1316 
    Parameters:
1317 
     - status
1318 
     - start_billing_date
1319 
     - end_billing_date
1320 
     - warehouse_id
1321 
    """
1322 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1323 
    return self.recv_getOrdersByBillingDate()
1324 
 
1325 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1326 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1327 
    args = getOrdersByBillingDate_args()
1328 
    args.status = status
1329 
    args.start_billing_date = start_billing_date
1330 
    args.end_billing_date = end_billing_date
1331 
    args.warehouse_id = warehouse_id
1332 
    args.write(self._oprot)
1333 
    self._oprot.writeMessageEnd()
1334 
    self._oprot.trans.flush()
1335 
 
1336 
  def recv_getOrdersByBillingDate(self, ):
1337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1338 
    if mtype == TMessageType.EXCEPTION:
1339 
      x = TApplicationException()
1340 
      x.read(self._iprot)
1341 
      self._iprot.readMessageEnd()
1342 
      raise x
1343 
    result = getOrdersByBillingDate_result()
1344 
    result.read(self._iprot)
1345 
    self._iprot.readMessageEnd()
3431 rajveer 1346 
    if result.success is not None:
999 varun.gupt 1347 
      return result.success
3431 rajveer 1348 
    if result.ex is not None:
999 varun.gupt 1349 
      raise result.ex
1350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1351 
 
3451 chandransh 1352 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1353 
    """
1354 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1355 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1356 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1357 
 
3427 chandransh 1358 
    Parameters:
1359 
     - fromShippingDate
1360 
     - toShippingDate
1361 
     - providerId
1362 
     - warehouseId
3451 chandransh 1363 
     - cod
3427 chandransh 1364 
    """
3451 chandransh 1365 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1366 
    return self.recv_getOrdersByShippingDate()
1367 
 
3451 chandransh 1368 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1369 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1370 
    args = getOrdersByShippingDate_args()
1371 
    args.fromShippingDate = fromShippingDate
1372 
    args.toShippingDate = toShippingDate
1373 
    args.providerId = providerId
1374 
    args.warehouseId = warehouseId
3451 chandransh 1375 
    args.cod = cod
3427 chandransh 1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getOrdersByShippingDate(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getOrdersByShippingDate_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
3431 rajveer 1390 
    if result.success is not None:
3427 chandransh 1391 
      return result.success
3431 rajveer 1392 
    if result.ex is not None:
3427 chandransh 1393 
      raise result.ex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1395 
 
1382 varun.gupt 1396 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1397 
    """
1398 
    Returns order ids for orders which can be returned
3431 rajveer 1399 
 
1382 varun.gupt 1400 
    Parameters:
1401 
     - customer_id
1402 
     - limit
1403 
    """
1404 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1405 
    return self.recv_getReturnableOrdersForCustomer()
1406 
 
1407 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1408 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1409 
    args = getReturnableOrdersForCustomer_args()
1410 
    args.customer_id = customer_id
1411 
    args.limit = limit
1412 
    args.write(self._oprot)
1413 
    self._oprot.writeMessageEnd()
1414 
    self._oprot.trans.flush()
1415 
 
1416 
  def recv_getReturnableOrdersForCustomer(self, ):
1417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1418 
    if mtype == TMessageType.EXCEPTION:
1419 
      x = TApplicationException()
1420 
      x.read(self._iprot)
1421 
      self._iprot.readMessageEnd()
1422 
      raise x
1423 
    result = getReturnableOrdersForCustomer_result()
1424 
    result.read(self._iprot)
1425 
    self._iprot.readMessageEnd()
3431 rajveer 1426 
    if result.success is not None:
1382 varun.gupt 1427 
      return result.success
3431 rajveer 1428 
    if result.ex is not None:
1382 varun.gupt 1429 
      raise result.ex
1430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1431 
 
1432 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1433 
    """
1434 
    Returns order ids for orders which can be cancelled
3431 rajveer 1435 
 
1382 varun.gupt 1436 
    Parameters:
1437 
     - customer_id
1438 
     - limit
1439 
    """
1440 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1441 
    return self.recv_getCancellableOrdersForCustomer()
1442 
 
1443 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1444 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1445 
    args = getCancellableOrdersForCustomer_args()
1446 
    args.customer_id = customer_id
1447 
    args.limit = limit
1448 
    args.write(self._oprot)
1449 
    self._oprot.writeMessageEnd()
1450 
    self._oprot.trans.flush()
1451 
 
1452 
  def recv_getCancellableOrdersForCustomer(self, ):
1453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1454 
    if mtype == TMessageType.EXCEPTION:
1455 
      x = TApplicationException()
1456 
      x.read(self._iprot)
1457 
      self._iprot.readMessageEnd()
1458 
      raise x
1459 
    result = getCancellableOrdersForCustomer_result()
1460 
    result.read(self._iprot)
1461 
    self._iprot.readMessageEnd()
3431 rajveer 1462 
    if result.success is not None:
1382 varun.gupt 1463 
      return result.success
3431 rajveer 1464 
    if result.ex is not None:
1382 varun.gupt 1465 
      raise result.ex
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1467 
 
483 rajveer 1468 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1469 
    """
1470 
    Parameters:
483 rajveer 1471 
     - orderId
1472 
     - status
1473 
     - description
94 ashish 1474 
    """
483 rajveer 1475 
    self.send_changeOrderStatus(orderId, status, description)
1476 
    return self.recv_changeOrderStatus()
94 ashish 1477 
 
483 rajveer 1478 
  def send_changeOrderStatus(self, orderId, status, description):
1479 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1480 
    args = changeOrderStatus_args()
1481 
    args.orderId = orderId
1482 
    args.status = status
1483 
    args.description = description
94 ashish 1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
483 rajveer 1488 
  def recv_changeOrderStatus(self, ):
94 ashish 1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
483 rajveer 1495 
    result = changeOrderStatus_result()
94 ashish 1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
3431 rajveer 1498 
    if result.success is not None:
94 ashish 1499 
      return result.success
3431 rajveer 1500 
    if result.ex is not None:
94 ashish 1501 
      raise result.ex
483 rajveer 1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1503 
 
1528 ankur.sing 1504 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1505 
    """
1528 ankur.sing 1506 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1507 
    only user who owns the transaction can view its order details.
3431 rajveer 1508 
 
94 ashish 1509 
    Parameters:
1510 
     - transactionId
1528 ankur.sing 1511 
     - customerId
94 ashish 1512 
    """
1528 ankur.sing 1513 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1514 
    return self.recv_getOrdersForTransaction()
94 ashish 1515 
 
1528 ankur.sing 1516 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1517 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1518 
    args = getOrdersForTransaction_args()
94 ashish 1519 
    args.transactionId = transactionId
1528 ankur.sing 1520 
    args.customerId = customerId
94 ashish 1521 
    args.write(self._oprot)
1522 
    self._oprot.writeMessageEnd()
1523 
    self._oprot.trans.flush()
1524 
 
483 rajveer 1525 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1527 
    if mtype == TMessageType.EXCEPTION:
1528 
      x = TApplicationException()
1529 
      x.read(self._iprot)
1530 
      self._iprot.readMessageEnd()
1531 
      raise x
483 rajveer 1532 
    result = getOrdersForTransaction_result()
94 ashish 1533 
    result.read(self._iprot)
1534 
    self._iprot.readMessageEnd()
3431 rajveer 1535 
    if result.success is not None:
94 ashish 1536 
      return result.success
3431 rajveer 1537 
    if result.ex is not None:
94 ashish 1538 
      raise result.ex
483 rajveer 1539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1540 
 
3014 chandransh 1541 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1542 
    """
3014 chandransh 1543 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1544 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1545 
 
94 ashish 1546 
    Parameters:
483 rajveer 1547 
     - customerId
1548 
     - from_date
1549 
     - to_date
3014 chandransh 1550 
     - statuses
94 ashish 1551 
    """
3014 chandransh 1552 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1553 
    return self.recv_getOrdersForCustomer()
94 ashish 1554 
 
3014 chandransh 1555 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1556 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1557 
    args = getOrdersForCustomer_args()
1558 
    args.customerId = customerId
1559 
    args.from_date = from_date
1560 
    args.to_date = to_date
3014 chandransh 1561 
    args.statuses = statuses
94 ashish 1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
483 rajveer 1566 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
483 rajveer 1573 
    result = getOrdersForCustomer_result()
94 ashish 1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
3431 rajveer 1576 
    if result.success is not None:
94 ashish 1577 
      return result.success
3431 rajveer 1578 
    if result.ex is not None:
94 ashish 1579 
      raise result.ex
483 rajveer 1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1581 
 
483 rajveer 1582 
  def createOrder(self, order):
94 ashish 1583 
    """
1584 
    Parameters:
483 rajveer 1585 
     - order
94 ashish 1586 
    """
483 rajveer 1587 
    self.send_createOrder(order)
1588 
    return self.recv_createOrder()
94 ashish 1589 
 
483 rajveer 1590 
  def send_createOrder(self, order):
1591 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1592 
    args = createOrder_args()
1593 
    args.order = order
94 ashish 1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
483 rajveer 1598 
  def recv_createOrder(self, ):
94 ashish 1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
483 rajveer 1605 
    result = createOrder_result()
94 ashish 1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
3431 rajveer 1608 
    if result.success is not None:
94 ashish 1609 
      return result.success
3431 rajveer 1610 
    if result.ex is not None:
94 ashish 1611 
      raise result.ex
483 rajveer 1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1613 
 
483 rajveer 1614 
  def getOrder(self, id):
94 ashish 1615 
    """
1616 
    Parameters:
483 rajveer 1617 
     - id
94 ashish 1618 
    """
483 rajveer 1619 
    self.send_getOrder(id)
1620 
    return self.recv_getOrder()
94 ashish 1621 
 
483 rajveer 1622 
  def send_getOrder(self, id):
1623 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1624 
    args = getOrder_args()
1625 
    args.id = id
94 ashish 1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
483 rajveer 1630 
  def recv_getOrder(self, ):
94 ashish 1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
483 rajveer 1637 
    result = getOrder_result()
94 ashish 1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
3431 rajveer 1640 
    if result.success is not None:
94 ashish 1641 
      return result.success
3431 rajveer 1642 
    if result.ex is not None:
94 ashish 1643 
      raise result.ex
483 rajveer 1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1645 
 
483 rajveer 1646 
  def getLineItemsForOrder(self, orderId):
94 ashish 1647 
    """
1648 
    Parameters:
483 rajveer 1649 
     - orderId
94 ashish 1650 
    """
483 rajveer 1651 
    self.send_getLineItemsForOrder(orderId)
1652 
    return self.recv_getLineItemsForOrder()
94 ashish 1653 
 
483 rajveer 1654 
  def send_getLineItemsForOrder(self, orderId):
1655 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1656 
    args = getLineItemsForOrder_args()
1657 
    args.orderId = orderId
94 ashish 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
483 rajveer 1662 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
483 rajveer 1669 
    result = getLineItemsForOrder_result()
94 ashish 1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
3431 rajveer 1672 
    if result.success is not None:
94 ashish 1673 
      return result.success
3431 rajveer 1674 
    if result.ex is not None:
94 ashish 1675 
      raise result.ex
483 rajveer 1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1677 
 
1528 ankur.sing 1678 
  def getOrderForCustomer(self, orderId, customerId):
1679 
    """
1680 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1681 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1682 
 
1528 ankur.sing 1683 
    Parameters:
1684 
     - orderId
1685 
     - customerId
1686 
    """
1687 
    self.send_getOrderForCustomer(orderId, customerId)
1688 
    return self.recv_getOrderForCustomer()
1689 
 
1690 
  def send_getOrderForCustomer(self, orderId, customerId):
1691 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1692 
    args = getOrderForCustomer_args()
1693 
    args.orderId = orderId
1694 
    args.customerId = customerId
1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
1699 
  def recv_getOrderForCustomer(self, ):
1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
1706 
    result = getOrderForCustomer_result()
1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
3431 rajveer 1709 
    if result.success is not None:
1528 ankur.sing 1710 
      return result.success
3431 rajveer 1711 
    if result.ex is not None:
1528 ankur.sing 1712 
      raise result.ex
1713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1714 
 
4444 rajveer 1715 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1716 
    """
1717 
    Parameters:
4394 rajveer 1718 
     - type
4444 rajveer 1719 
     - warehouseId
4394 rajveer 1720 
     - status
1721 
     - timestamp
3064 chandransh 1722 
    """
4444 rajveer 1723 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1724 
    return self.recv_getAlerts()
1725 
 
4444 rajveer 1726 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1727 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1728 
    args = getAlerts_args()
4394 rajveer 1729 
    args.type = type
4444 rajveer 1730 
    args.warehouseId = warehouseId
4394 rajveer 1731 
    args.status = status
1732 
    args.timestamp = timestamp
3064 chandransh 1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getAlerts(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getAlerts_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
3064 chandransh 1748 
      return result.success
1749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1750 
 
4444 rajveer 1751 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1752 
    """
1753 
    Parameters:
1754 
     - type
4444 rajveer 1755 
     - warehouseId
4394 rajveer 1756 
     - description
3064 chandransh 1757 
    """
4444 rajveer 1758 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1759 
    self.recv_addAlert()
3064 chandransh 1760 
 
4444 rajveer 1761 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1762 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1763 
    args = addAlert_args()
3064 chandransh 1764 
    args.type = type
4444 rajveer 1765 
    args.warehouseId = warehouseId
4394 rajveer 1766 
    args.description = description
3064 chandransh 1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
4394 rajveer 1771 
  def recv_addAlert(self, ):
3064 chandransh 1772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1773 
    if mtype == TMessageType.EXCEPTION:
1774 
      x = TApplicationException()
1775 
      x.read(self._iprot)
1776 
      self._iprot.readMessageEnd()
1777 
      raise x
4394 rajveer 1778 
    result = addAlert_result()
3064 chandransh 1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
1781 
    return
1782 
 
4444 rajveer 1783 
  def markAlertsAsSeen(self, warehouseId):
1784 
    """
1785 
    Parameters:
1786 
     - warehouseId
1787 
    """
1788 
    self.send_markAlertsAsSeen(warehouseId)
1789 
    self.recv_markAlertsAsSeen()
1790 
 
1791 
  def send_markAlertsAsSeen(self, warehouseId):
1792 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1793 
    args = markAlertsAsSeen_args()
1794 
    args.warehouseId = warehouseId
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_markAlertsAsSeen(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = markAlertsAsSeen_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
1809 
    return
1810 
 
3064 chandransh 1811 
  def getValidOrderCount(self, ):
1812 
    """
1813 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1814 
    """
1815 
    self.send_getValidOrderCount()
1816 
    return self.recv_getValidOrderCount()
1817 
 
1818 
  def send_getValidOrderCount(self, ):
1819 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1820 
    args = getValidOrderCount_args()
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_getValidOrderCount(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 = getValidOrderCount_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
3431 rajveer 1835 
    if result.success is not None:
3064 chandransh 1836 
      return result.success
1837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1838 
 
1839 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1840 
    """
1841 
    Returns the number of distinct customers who have done successful transactions
1842 
    """
1843 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1844 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1845 
 
1846 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1847 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1848 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1849 
    args.write(self._oprot)
1850 
    self._oprot.writeMessageEnd()
1851 
    self._oprot.trans.flush()
1852 
 
1853 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1855 
    if mtype == TMessageType.EXCEPTION:
1856 
      x = TApplicationException()
1857 
      x.read(self._iprot)
1858 
      self._iprot.readMessageEnd()
1859 
      raise x
1860 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1861 
    result.read(self._iprot)
1862 
    self._iprot.readMessageEnd()
3431 rajveer 1863 
    if result.success is not None:
3064 chandransh 1864 
      return result.success
1865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1866 
 
1867 
  def getValidOrdersAmountRange(self, ):
1868 
    """
1869 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1870 
    List contains two values, first minimum amount and second maximum amount.
1871 
    """
1872 
    self.send_getValidOrdersAmountRange()
1873 
    return self.recv_getValidOrdersAmountRange()
1874 
 
1875 
  def send_getValidOrdersAmountRange(self, ):
1876 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1877 
    args = getValidOrdersAmountRange_args()
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_getValidOrdersAmountRange(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = getValidOrdersAmountRange_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
3431 rajveer 1892 
    if result.success is not None:
3064 chandransh 1893 
      return result.success
1894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1895 
 
1896 
  def getValidOrders(self, limit):
1897 
    """
1898 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1899 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1900 
 
3064 chandransh 1901 
    Parameters:
1902 
     - limit
1903 
    """
1904 
    self.send_getValidOrders(limit)
1905 
    return self.recv_getValidOrders()
1906 
 
1907 
  def send_getValidOrders(self, limit):
1908 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1909 
    args = getValidOrders_args()
1910 
    args.limit = limit
1911 
    args.write(self._oprot)
1912 
    self._oprot.writeMessageEnd()
1913 
    self._oprot.trans.flush()
1914 
 
1915 
  def recv_getValidOrders(self, ):
1916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1917 
    if mtype == TMessageType.EXCEPTION:
1918 
      x = TApplicationException()
1919 
      x.read(self._iprot)
1920 
      self._iprot.readMessageEnd()
1921 
      raise x
1922 
    result = getValidOrders_result()
1923 
    result.read(self._iprot)
1924 
    self._iprot.readMessageEnd()
3431 rajveer 1925 
    if result.success is not None:
3064 chandransh 1926 
      return result.success
1927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1928 
 
1220 chandransh 1929 
  def batchOrders(self, warehouseId):
1930 
    """
1931 
    Create a batch of all the pending orders for the given warehouse.
1932 
    The returned list is orderd by created_timestamp.
1933 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1934 
 
1220 chandransh 1935 
    Parameters:
1936 
     - warehouseId
1937 
    """
1938 
    self.send_batchOrders(warehouseId)
1939 
    return self.recv_batchOrders()
1940 
 
1941 
  def send_batchOrders(self, warehouseId):
1942 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1943 
    args = batchOrders_args()
1944 
    args.warehouseId = warehouseId
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_batchOrders(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = batchOrders_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
1220 chandransh 1960 
      return result.success
3431 rajveer 1961 
    if result.ex is not None:
1220 chandransh 1962 
      raise result.ex
1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1964 
 
1208 chandransh 1965 
  def markOrderAsOutOfStock(self, orderId):
1966 
    """
1967 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1968 
 
1208 chandransh 1969 
    Parameters:
1970 
     - orderId
1971 
    """
1972 
    self.send_markOrderAsOutOfStock(orderId)
1973 
    return self.recv_markOrderAsOutOfStock()
1974 
 
1975 
  def send_markOrderAsOutOfStock(self, orderId):
1976 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1977 
    args = markOrderAsOutOfStock_args()
1978 
    args.orderId = orderId
1979 
    args.write(self._oprot)
1980 
    self._oprot.writeMessageEnd()
1981 
    self._oprot.trans.flush()
1982 
 
1983 
  def recv_markOrderAsOutOfStock(self, ):
1984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1985 
    if mtype == TMessageType.EXCEPTION:
1986 
      x = TApplicationException()
1987 
      x.read(self._iprot)
1988 
      self._iprot.readMessageEnd()
1989 
      raise x
1990 
    result = markOrderAsOutOfStock_result()
1991 
    result.read(self._iprot)
1992 
    self._iprot.readMessageEnd()
3431 rajveer 1993 
    if result.success is not None:
1208 chandransh 1994 
      return result.success
3431 rajveer 1995 
    if result.ex is not None:
1208 chandransh 1996 
      raise result.ex
1997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1998 
 
3064 chandransh 1999 
  def verifyOrder(self, orderId):
759 chandransh 2000 
    """
3064 chandransh 2001 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2002 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2003 
    used for all other orders as well.
2004 
    Throws an exception if no such order exists.
3431 rajveer 2005 
 
759 chandransh 2006 
    Parameters:
3064 chandransh 2007 
     - orderId
759 chandransh 2008 
    """
3064 chandransh 2009 
    self.send_verifyOrder(orderId)
2010 
    return self.recv_verifyOrder()
759 chandransh 2011 
 
3064 chandransh 2012 
  def send_verifyOrder(self, orderId):
2013 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2014 
    args = verifyOrder_args()
2015 
    args.orderId = orderId
759 chandransh 2016 
    args.write(self._oprot)
2017 
    self._oprot.writeMessageEnd()
2018 
    self._oprot.trans.flush()
2019 
 
3064 chandransh 2020 
  def recv_verifyOrder(self, ):
759 chandransh 2021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2022 
    if mtype == TMessageType.EXCEPTION:
2023 
      x = TApplicationException()
2024 
      x.read(self._iprot)
2025 
      self._iprot.readMessageEnd()
2026 
      raise x
3064 chandransh 2027 
    result = verifyOrder_result()
759 chandransh 2028 
    result.read(self._iprot)
2029 
    self._iprot.readMessageEnd()
3431 rajveer 2030 
    if result.success is not None:
759 chandransh 2031 
      return result.success
3431 rajveer 2032 
    if result.ex is not None:
759 chandransh 2033 
      raise result.ex
3064 chandransh 2034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2035 
 
3064 chandransh 2036 
  def acceptOrder(self, orderId):
1113 chandransh 2037 
    """
3064 chandransh 2038 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2039 
    given order is not a COD order, it also captures the payment if the same has
2040 
    not been captured.
2041 
    Throws an exception if no such order exists.
3431 rajveer 2042 
 
1113 chandransh 2043 
    Parameters:
3064 chandransh 2044 
     - orderId
1113 chandransh 2045 
    """
3064 chandransh 2046 
    self.send_acceptOrder(orderId)
2047 
    return self.recv_acceptOrder()
1113 chandransh 2048 
 
3064 chandransh 2049 
  def send_acceptOrder(self, orderId):
2050 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2051 
    args = acceptOrder_args()
2052 
    args.orderId = orderId
1113 chandransh 2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
3064 chandransh 2057 
  def recv_acceptOrder(self, ):
1113 chandransh 2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
3064 chandransh 2064 
    result = acceptOrder_result()
1113 chandransh 2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
3431 rajveer 2067 
    if result.success is not None:
1113 chandransh 2068 
      return result.success
3431 rajveer 2069 
    if result.ex is not None:
1113 chandransh 2070 
      raise result.ex
3064 chandransh 2071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2072 
 
4283 anupam.sin 2073 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2074 
    """
3064 chandransh 2075 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2076 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2077 
    the IMEI no. if a -1 is supplied.
2078 
    Also, it generates an invoice number for the order, marks the order as
2079 
    BILLED and sets the billing timestamp.
2080 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2081 
 
1135 chandransh 2082 
    Parameters:
3064 chandransh 2083 
     - orderId
2084 
     - invoice_number
4283 anupam.sin 2085 
     - imeiNumber
2086 
     - itemNumber
3064 chandransh 2087 
     - billed_by
4264 rajveer 2088 
     - jacketNumber
4283 anupam.sin 2089 
     - billingType
2090 
     - vendorId
1135 chandransh 2091 
    """
4283 anupam.sin 2092 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2093 
    return self.recv_addBillingDetails()
1135 chandransh 2094 
 
4283 anupam.sin 2095 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2096 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2097 
    args = addBillingDetails_args()
2098 
    args.orderId = orderId
2099 
    args.invoice_number = invoice_number
4283 anupam.sin 2100 
    args.imeiNumber = imeiNumber
2101 
    args.itemNumber = itemNumber
3064 chandransh 2102 
    args.billed_by = billed_by
4264 rajveer 2103 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2104 
    args.billingType = billingType
2105 
    args.vendorId = vendorId
1135 chandransh 2106 
    args.write(self._oprot)
2107 
    self._oprot.writeMessageEnd()
2108 
    self._oprot.trans.flush()
2109 
 
3064 chandransh 2110 
  def recv_addBillingDetails(self, ):
1135 chandransh 2111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2112 
    if mtype == TMessageType.EXCEPTION:
2113 
      x = TApplicationException()
2114 
      x.read(self._iprot)
2115 
      self._iprot.readMessageEnd()
2116 
      raise x
3064 chandransh 2117 
    result = addBillingDetails_result()
1135 chandransh 2118 
    result.read(self._iprot)
2119 
    self._iprot.readMessageEnd()
3431 rajveer 2120 
    if result.success is not None:
3064 chandransh 2121 
      return result.success
3431 rajveer 2122 
    if result.ex is not None:
1135 chandransh 2123 
      raise result.ex
3064 chandransh 2124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2125 
 
4579 rajveer 2126 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2127 
    """
2128 
    Add the invoice number to the order.
2129 
 
2130 
    Parameters:
2131 
     - orderId
2132 
     - invoiceNumber
2133 
    """
2134 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2135 
    self.recv_addInvoiceNumber()
2136 
 
2137 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2138 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2139 
    args = addInvoiceNumber_args()
2140 
    args.orderId = orderId
2141 
    args.invoiceNumber = invoiceNumber
2142 
    args.write(self._oprot)
2143 
    self._oprot.writeMessageEnd()
2144 
    self._oprot.trans.flush()
2145 
 
2146 
  def recv_addInvoiceNumber(self, ):
2147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2148 
    if mtype == TMessageType.EXCEPTION:
2149 
      x = TApplicationException()
2150 
      x.read(self._iprot)
2151 
      self._iprot.readMessageEnd()
2152 
      raise x
2153 
    result = addInvoiceNumber_result()
2154 
    result.read(self._iprot)
2155 
    self._iprot.readMessageEnd()
2156 
    if result.ex is not None:
2157 
      raise result.ex
2158 
    return
2159 
 
3064 chandransh 2160 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2161 
    """
3064 chandransh 2162 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2163 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2164 
 
1408 ankur.sing 2165 
    Parameters:
3064 chandransh 2166 
     - warehouseId
1408 ankur.sing 2167 
     - providerId
3064 chandransh 2168 
     - cod
1408 ankur.sing 2169 
    """
3064 chandransh 2170 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2171 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2172 
 
3064 chandransh 2173 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2174 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2175 
    args = markOrdersAsManifested_args()
2176 
    args.warehouseId = warehouseId
1408 ankur.sing 2177 
    args.providerId = providerId
3064 chandransh 2178 
    args.cod = cod
1408 ankur.sing 2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
3064 chandransh 2183 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
3064 chandransh 2190 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
3431 rajveer 2193 
    if result.success is not None:
1408 ankur.sing 2194 
      return result.success
3431 rajveer 2195 
    if result.ex is not None:
3064 chandransh 2196 
      raise result.ex
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2198 
 
4410 rajveer 2199 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2200 
    """
2201 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2202 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2203 
 
2204 
    Parameters:
2205 
     - warehouseId
2206 
     - providerId
2207 
     - cod
2208 
    """
2209 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2210 
    return self.recv_markOrdersAsShippedFromWarehouse()
2211 
 
2212 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2213 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2214 
    args = markOrdersAsShippedFromWarehouse_args()
2215 
    args.warehouseId = warehouseId
2216 
    args.providerId = providerId
2217 
    args.cod = cod
2218 
    args.write(self._oprot)
2219 
    self._oprot.writeMessageEnd()
2220 
    self._oprot.trans.flush()
2221 
 
2222 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2224 
    if mtype == TMessageType.EXCEPTION:
2225 
      x = TApplicationException()
2226 
      x.read(self._iprot)
2227 
      self._iprot.readMessageEnd()
2228 
      raise x
2229 
    result = markOrdersAsShippedFromWarehouse_result()
2230 
    result.read(self._iprot)
2231 
    self._iprot.readMessageEnd()
2232 
    if result.success is not None:
2233 
      return result.success
2234 
    if result.ex is not None:
2235 
      raise result.ex
2236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2237 
 
3064 chandransh 2238 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2239 
    """
3064 chandransh 2240 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2241 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2242 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2243 
 
94 ashish 2244 
    Parameters:
3064 chandransh 2245 
     - providerId
2246 
     - pickupDetails
304 ashish 2247 
    """
3064 chandransh 2248 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2249 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2250 
 
3064 chandransh 2251 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2252 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2253 
    args = markOrdersAsPickedUp_args()
2254 
    args.providerId = providerId
2255 
    args.pickupDetails = pickupDetails
304 ashish 2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
3064 chandransh 2260 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
3064 chandransh 2267 
    result = markOrdersAsPickedUp_result()
304 ashish 2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
304 ashish 2271 
      return result.success
3431 rajveer 2272 
    if result.ex is not None:
3064 chandransh 2273 
      raise result.ex
2274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2275 
 
3064 chandransh 2276 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2277 
    """
3064 chandransh 2278 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2279 
    the name of the receiver.
2280 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2281 
 
304 ashish 2282 
    Parameters:
3064 chandransh 2283 
     - providerId
2284 
     - deliveredOrders
304 ashish 2285 
    """
3064 chandransh 2286 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2287 
    self.recv_markOrdersAsDelivered()
304 ashish 2288 
 
3064 chandransh 2289 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2290 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2291 
    args = markOrdersAsDelivered_args()
2292 
    args.providerId = providerId
2293 
    args.deliveredOrders = deliveredOrders
304 ashish 2294 
    args.write(self._oprot)
2295 
    self._oprot.writeMessageEnd()
2296 
    self._oprot.trans.flush()
2297 
 
3064 chandransh 2298 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2300 
    if mtype == TMessageType.EXCEPTION:
2301 
      x = TApplicationException()
2302 
      x.read(self._iprot)
2303 
      self._iprot.readMessageEnd()
2304 
      raise x
3064 chandransh 2305 
    result = markOrdersAsDelivered_result()
304 ashish 2306 
    result.read(self._iprot)
2307 
    self._iprot.readMessageEnd()
3431 rajveer 2308 
    if result.ex is not None:
3064 chandransh 2309 
      raise result.ex
304 ashish 2310 
    return
2311 
 
3064 chandransh 2312 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2313 
    """
3064 chandransh 2314 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2315 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2316 
 
3064 chandransh 2317 
    Parameters:
2318 
     - providerId
2319 
     - returnedOrders
1596 ankur.sing 2320 
    """
3064 chandransh 2321 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2322 
    self.recv_markOrdersAsFailed()
304 ashish 2323 
 
3064 chandransh 2324 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2325 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2326 
    args = markOrdersAsFailed_args()
2327 
    args.providerId = providerId
2328 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
3064 chandransh 2333 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
3064 chandransh 2340 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
3431 rajveer 2343 
    if result.ex is not None:
3064 chandransh 2344 
      raise result.ex
2345 
    return
1596 ankur.sing 2346 
 
3064 chandransh 2347 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2348 
    """
3064 chandransh 2349 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2350 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2351 
 
3064 chandransh 2352 
    Parameters:
2353 
     - providerId
2354 
     - undeliveredOrders
1627 ankur.sing 2355 
    """
3064 chandransh 2356 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2357 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2358 
 
3064 chandransh 2359 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2360 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2361 
    args = updateNonDeliveryReason_args()
2362 
    args.providerId = providerId
2363 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
3064 chandransh 2368 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
3064 chandransh 2375 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
4581 phani.kuma 2378 
    if result.success is not None:
2379 
      return result.success
3431 rajveer 2380 
    if result.ex is not None:
3064 chandransh 2381 
      raise result.ex
4581 phani.kuma 2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2383 
 
3064 chandransh 2384 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2385 
    """
3064 chandransh 2386 
    Returns the list of orders whose delivery time has passed but have not been
2387 
    delivered yet for the given provider and warehouse. To get a complete list of
2388 
    undelivered orders, pass them as -1.
2389 
    Returns an empty list if no such orders exist.
3431 rajveer 2390 
 
1886 ankur.sing 2391 
    Parameters:
3064 chandransh 2392 
     - providerId
2393 
     - warehouseId
1886 ankur.sing 2394 
    """
3064 chandransh 2395 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2396 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2397 
 
3064 chandransh 2398 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2399 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2400 
    args = getUndeliveredOrders_args()
2401 
    args.providerId = providerId
2402 
    args.warehouseId = warehouseId
1886 ankur.sing 2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
3064 chandransh 2407 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
3064 chandransh 2414 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
3431 rajveer 2417 
    if result.success is not None:
1886 ankur.sing 2418 
      return result.success
3064 chandransh 2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2420 
 
2536 chandransh 2421 
  def toggleDOAFlag(self, orderId):
2422 
    """
2423 
    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.
2424 
    Returns the final flag status.
2425 
    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 2426 
 
2536 chandransh 2427 
    Parameters:
2428 
     - orderId
2429 
    """
2430 
    self.send_toggleDOAFlag(orderId)
2431 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2432 
 
2536 chandransh 2433 
  def send_toggleDOAFlag(self, orderId):
2434 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2435 
    args = toggleDOAFlag_args()
2436 
    args.orderId = orderId
2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
2441 
  def recv_toggleDOAFlag(self, ):
2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
2448 
    result = toggleDOAFlag_result()
2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
3431 rajveer 2451 
    if result.success is not None:
2536 chandransh 2452 
      return result.success
3431 rajveer 2453 
    if result.ex is not None:
2536 chandransh 2454 
      raise result.ex
2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2456 
 
4454 rajveer 2457 
  def markOrderDoaRequestReceived(self, orderId):
2458 
    """
2459 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2460 
 
2461 
    Parameters:
2462 
     - orderId
2463 
    """
2464 
    self.send_markOrderDoaRequestReceived(orderId)
2465 
    return self.recv_markOrderDoaRequestReceived()
2466 
 
2467 
  def send_markOrderDoaRequestReceived(self, orderId):
2468 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2469 
    args = markOrderDoaRequestReceived_args()
2470 
    args.orderId = orderId
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_markOrderDoaRequestReceived(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = markOrderDoaRequestReceived_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.success is not None:
2486 
      return result.success
2487 
    if result.ex is not None:
2488 
      raise result.ex
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2490 
 
2491 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2492 
    """
2493 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2494 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2495 
 
2496 
    Parameters:
2497 
     - orderId
2498 
     - isAuthorized
2499 
    """
2500 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2501 
    return self.recv_markOrderDoaRequestAuthorized()
2502 
 
2503 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2504 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2505 
    args = markOrderDoaRequestAuthorized_args()
2506 
    args.orderId = orderId
2507 
    args.isAuthorized = isAuthorized
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_markOrderDoaRequestAuthorized(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = markOrderDoaRequestAuthorized_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
2522 
    if result.success is not None:
2523 
      return result.success
2524 
    if result.ex is not None:
2525 
      raise result.ex
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2527 
 
4488 rajveer 2528 
  def markOrderReturnRequestReceived(self, orderId):
2529 
    """
2530 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2531 
 
2532 
    Parameters:
2533 
     - orderId
2534 
    """
2535 
    self.send_markOrderReturnRequestReceived(orderId)
2536 
    return self.recv_markOrderReturnRequestReceived()
2537 
 
2538 
  def send_markOrderReturnRequestReceived(self, orderId):
2539 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2540 
    args = markOrderReturnRequestReceived_args()
2541 
    args.orderId = orderId
2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_markOrderReturnRequestReceived(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = markOrderReturnRequestReceived_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
2556 
    if result.success is not None:
2557 
      return result.success
2558 
    if result.ex is not None:
2559 
      raise result.ex
2560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2561 
 
2562 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2563 
    """
2564 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2565 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2566 
 
2567 
    Parameters:
2568 
     - orderId
2569 
     - isAuthorized
2570 
    """
2571 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2572 
    return self.recv_markOrderReturnRequestAuthorized()
2573 
 
2574 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2575 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2576 
    args = markOrderReturnRequestAuthorized_args()
2577 
    args.orderId = orderId
2578 
    args.isAuthorized = isAuthorized
2579 
    args.write(self._oprot)
2580 
    self._oprot.writeMessageEnd()
2581 
    self._oprot.trans.flush()
2582 
 
2583 
  def recv_markOrderReturnRequestAuthorized(self, ):
2584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2585 
    if mtype == TMessageType.EXCEPTION:
2586 
      x = TApplicationException()
2587 
      x.read(self._iprot)
2588 
      self._iprot.readMessageEnd()
2589 
      raise x
2590 
    result = markOrderReturnRequestAuthorized_result()
2591 
    result.read(self._iprot)
2592 
    self._iprot.readMessageEnd()
2593 
    if result.success is not None:
2594 
      return result.success
2595 
    if result.ex is not None:
2596 
      raise result.ex
2597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2598 
 
4579 rajveer 2599 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2600 
    """
2601 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2602 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2603 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2604 
    For any other status, it returns false.
2605 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2606 
 
2536 chandransh 2607 
    Parameters:
2608 
     - orderId
4579 rajveer 2609 
     - providerId
2536 chandransh 2610 
    """
4579 rajveer 2611 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2612 
    return self.recv_requestPickupNumber()
2613 
 
4579 rajveer 2614 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2615 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2616 
    args = requestPickupNumber_args()
2617 
    args.orderId = orderId
4579 rajveer 2618 
    args.providerId = providerId
2536 chandransh 2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_requestPickupNumber(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = requestPickupNumber_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
3431 rajveer 2633 
    if result.success is not None:
2536 chandransh 2634 
      return result.success
3431 rajveer 2635 
    if result.ex is not None:
2536 chandransh 2636 
      raise result.ex
2637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2638 
 
4602 rajveer 2639 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2640 
    """
4452 rajveer 2641 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2642 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2643 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2644 
    	3. Returns true
2591 chandransh 2645 
    If the order is in any other status, it returns false.
2536 chandransh 2646 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2647 
 
2536 chandransh 2648 
    Parameters:
2649 
     - orderId
2650 
     - pickupNumber
4602 rajveer 2651 
     - providerId
2536 chandransh 2652 
    """
4602 rajveer 2653 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2654 
    return self.recv_authorizePickup()
2655 
 
4602 rajveer 2656 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2657 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2658 
    args = authorizePickup_args()
2659 
    args.orderId = orderId
2660 
    args.pickupNumber = pickupNumber
4602 rajveer 2661 
    args.providerId = providerId
2536 chandransh 2662 
    args.write(self._oprot)
2663 
    self._oprot.writeMessageEnd()
2664 
    self._oprot.trans.flush()
2665 
 
2666 
  def recv_authorizePickup(self, ):
2667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2668 
    if mtype == TMessageType.EXCEPTION:
2669 
      x = TApplicationException()
2670 
      x.read(self._iprot)
2671 
      self._iprot.readMessageEnd()
2672 
      raise x
2673 
    result = authorizePickup_result()
2674 
    result.read(self._iprot)
2675 
    self._iprot.readMessageEnd()
3431 rajveer 2676 
    if result.success is not None:
2536 chandransh 2677 
      return result.success
3431 rajveer 2678 
    if result.ex is not None:
2536 chandransh 2679 
      raise result.ex
2680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2681 
 
2764 chandransh 2682 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2683 
    """
2684 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2685 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2686 
 
2764 chandransh 2687 
    Parameters:
2688 
     - providerId
2689 
     - pickupDetails
2690 
    """
2691 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2692 
    return self.recv_markDoasAsPickedUp()
2693 
 
2694 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2695 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2696 
    args = markDoasAsPickedUp_args()
2697 
    args.providerId = providerId
2698 
    args.pickupDetails = pickupDetails
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_markDoasAsPickedUp(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = markDoasAsPickedUp_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
3431 rajveer 2713 
    if result.success is not None:
2764 chandransh 2714 
      return result.success
2715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2716 
 
4479 rajveer 2717 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2718 
    """
4452 rajveer 2719 
    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 2720 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2721 
    If the order is in any other state, it returns false.
2722 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2723 
 
2591 chandransh 2724 
    Parameters:
2725 
     - orderId
4479 rajveer 2726 
     - receiveCondition
2591 chandransh 2727 
    """
4479 rajveer 2728 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2729 
    return self.recv_receiveReturn()
2536 chandransh 2730 
 
4479 rajveer 2731 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2732 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2733 
    args = receiveReturn_args()
2591 chandransh 2734 
    args.orderId = orderId
4479 rajveer 2735 
    args.receiveCondition = receiveCondition
2591 chandransh 2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
2616 chandransh 2740 
  def recv_receiveReturn(self, ):
2591 chandransh 2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
2616 chandransh 2747 
    result = receiveReturn_result()
2591 chandransh 2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
3431 rajveer 2750 
    if result.success is not None:
2591 chandransh 2751 
      return result.success
3431 rajveer 2752 
    if result.ex is not None:
2591 chandransh 2753 
      raise result.ex
2616 chandransh 2754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2755 
 
2756 
  def validateDoa(self, orderId, isValid):
2757 
    """
4452 rajveer 2758 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2759 
    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 2760 
    If the order is in any other state, it returns false.
2761 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2762 
 
2591 chandransh 2763 
    Parameters:
2764 
     - orderId
2765 
     - isValid
2766 
    """
2767 
    self.send_validateDoa(orderId, isValid)
2768 
    return self.recv_validateDoa()
2769 
 
2770 
  def send_validateDoa(self, orderId, isValid):
2771 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2772 
    args = validateDoa_args()
2773 
    args.orderId = orderId
2774 
    args.isValid = isValid
2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
2779 
  def recv_validateDoa(self, ):
2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
2786 
    result = validateDoa_result()
2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
3431 rajveer 2789 
    if result.success is not None:
2591 chandransh 2790 
      return result.success
3431 rajveer 2791 
    if result.ex is not None:
2591 chandransh 2792 
      raise result.ex
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2794 
 
4495 rajveer 2795 
  def validateReturnProduct(self, orderId, isUsable):
2796 
    """
2797 
    Parameters:
2798 
     - orderId
2799 
     - isUsable
2800 
    """
2801 
    self.send_validateReturnProduct(orderId, isUsable)
2802 
    return self.recv_validateReturnProduct()
2803 
 
2804 
  def send_validateReturnProduct(self, orderId, isUsable):
2805 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2806 
    args = validateReturnProduct_args()
2807 
    args.orderId = orderId
2808 
    args.isUsable = isUsable
2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2813 
  def recv_validateReturnProduct(self, ):
2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
2820 
    result = validateReturnProduct_result()
2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
2823 
    if result.success is not None:
2824 
      return result.success
2825 
    if result.ex is not None:
2826 
      raise result.ex
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2828 
 
2616 chandransh 2829 
  def reshipOrder(self, orderId):
2830 
    """
4484 rajveer 2831 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2832 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2833 
    	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 2834 
 
2835 
    If the order is in DOA_CERT_VALID state, it does the following:
2836 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2837 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2838 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2839 
 
2616 chandransh 2840 
    Returns the id of the newly created order.
3431 rajveer 2841 
 
2616 chandransh 2842 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2843 
 
2616 chandransh 2844 
    Parameters:
2845 
     - orderId
2846 
    """
2847 
    self.send_reshipOrder(orderId)
2848 
    return self.recv_reshipOrder()
2591 chandransh 2849 
 
2616 chandransh 2850 
  def send_reshipOrder(self, orderId):
2851 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2852 
    args = reshipOrder_args()
2853 
    args.orderId = orderId
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_reshipOrder(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = reshipOrder_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
3431 rajveer 2868 
    if result.success is not None:
2616 chandransh 2869 
      return result.success
3431 rajveer 2870 
    if result.ex is not None:
2616 chandransh 2871 
      raise result.ex
2872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2873 
 
3226 chandransh 2874 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2875 
    """
4484 rajveer 2876 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2877 
    	1. Creates a refund request for batch processing.
2878 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2879 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2880 
 
2616 chandransh 2881 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2882 
    	1. Creates a refund request for batch processing.
3226 chandransh 2883 
    	2. Cancels the reservation of the item in the warehouse.
2884 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2885 
 
3226 chandransh 2886 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2887 
    	1. Cancels the reservation of the item in the warehouse.
2888 
    	2. Marks the current order as CANCELED.
2889 
 
2890 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2891 
 
2616 chandransh 2892 
    Returns True if it is successful, False otherwise.
3431 rajveer 2893 
 
2616 chandransh 2894 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2895 
 
2616 chandransh 2896 
    Parameters:
2897 
     - orderId
3226 chandransh 2898 
     - refundedBy
2899 
     - reason
2616 chandransh 2900 
    """
3226 chandransh 2901 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2902 
    return self.recv_refundOrder()
2903 
 
3226 chandransh 2904 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2905 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2906 
    args = refundOrder_args()
2907 
    args.orderId = orderId
3226 chandransh 2908 
    args.refundedBy = refundedBy
2909 
    args.reason = reason
2616 chandransh 2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_refundOrder(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = refundOrder_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
3431 rajveer 2924 
    if result.success is not None:
2616 chandransh 2925 
      return result.success
3431 rajveer 2926 
    if result.ex is not None:
2616 chandransh 2927 
      raise result.ex
2928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2929 
 
2690 chandransh 2930 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2931 
    """
2932 
    Get all return orders created between the from and to dates for the given warehouse.
2933 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2934 
 
2690 chandransh 2935 
    Parameters:
2936 
     - warehouseId
2937 
     - fromDate
2938 
     - toDate
2939 
    """
2940 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2941 
    return self.recv_getReturnOrders()
2616 chandransh 2942 
 
2690 chandransh 2943 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2944 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2945 
    args = getReturnOrders_args()
2946 
    args.warehouseId = warehouseId
2947 
    args.fromDate = fromDate
2948 
    args.toDate = toDate
2949 
    args.write(self._oprot)
2950 
    self._oprot.writeMessageEnd()
2951 
    self._oprot.trans.flush()
2952 
 
2953 
  def recv_getReturnOrders(self, ):
2954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2955 
    if mtype == TMessageType.EXCEPTION:
2956 
      x = TApplicationException()
2957 
      x.read(self._iprot)
2958 
      self._iprot.readMessageEnd()
2959 
      raise x
2960 
    result = getReturnOrders_result()
2961 
    result.read(self._iprot)
2962 
    self._iprot.readMessageEnd()
3431 rajveer 2963 
    if result.success is not None:
2690 chandransh 2964 
      return result.success
2965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2966 
 
2700 chandransh 2967 
  def getReturnOrder(self, id):
2968 
    """
2969 
    Returns the ReturnOrder corresponding to the given id.
2970 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2971 
 
2700 chandransh 2972 
    Parameters:
2973 
     - id
2974 
    """
2975 
    self.send_getReturnOrder(id)
2976 
    return self.recv_getReturnOrder()
2977 
 
2978 
  def send_getReturnOrder(self, id):
2979 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2980 
    args = getReturnOrder_args()
2981 
    args.id = id
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_getReturnOrder(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = getReturnOrder_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
3431 rajveer 2996 
    if result.success is not None:
2700 chandransh 2997 
      return result.success
3431 rajveer 2998 
    if result.ex is not None:
2700 chandransh 2999 
      raise result.ex
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3001 
 
2690 chandransh 3002 
  def processReturn(self, returnOrderId):
3003 
    """
3004 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3005 
 
2690 chandransh 3006 
    Parameters:
3007 
     - returnOrderId
3008 
    """
3009 
    self.send_processReturn(returnOrderId)
3010 
    self.recv_processReturn()
3011 
 
3012 
  def send_processReturn(self, returnOrderId):
3013 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3014 
    args = processReturn_args()
3015 
    args.returnOrderId = returnOrderId
3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3020 
  def recv_processReturn(self, ):
3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3027 
    result = processReturn_result()
3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
3431 rajveer 3030 
    if result.ex is not None:
2690 chandransh 3031 
      raise result.ex
3032 
    return
3033 
 
2819 chandransh 3034 
  def createPurchaseOrder(self, warehouseId):
3035 
    """
4586 mandeep.dh 3036 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3037 
    Returns the list of PO no. of the newly created purchase order.
3038 
    Returns null if no new purchase order had to be created.
3431 rajveer 3039 
 
2819 chandransh 3040 
    Parameters:
3041 
     - warehouseId
3042 
    """
3043 
    self.send_createPurchaseOrder(warehouseId)
3044 
    return self.recv_createPurchaseOrder()
2690 chandransh 3045 
 
2819 chandransh 3046 
  def send_createPurchaseOrder(self, warehouseId):
3047 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3048 
    args = createPurchaseOrder_args()
3049 
    args.warehouseId = warehouseId
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_createPurchaseOrder(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = createPurchaseOrder_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3431 rajveer 3064 
    if result.success is not None:
2819 chandransh 3065 
      return result.success
3431 rajveer 3066 
    if result.ex is not None:
2819 chandransh 3067 
      raise result.ex
3068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3069 
 
3451 chandransh 3070 
  def updateWeight(self, orderId, weight):
3071 
    """
3072 
    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 3073 
 
3451 chandransh 3074 
    Parameters:
3075 
     - orderId
3076 
     - weight
3077 
    """
3078 
    self.send_updateWeight(orderId, weight)
3079 
    return self.recv_updateWeight()
3080 
 
3081 
  def send_updateWeight(self, orderId, weight):
3082 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3083 
    args = updateWeight_args()
3084 
    args.orderId = orderId
3085 
    args.weight = weight
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
3090 
  def recv_updateWeight(self, ):
3091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3092 
    if mtype == TMessageType.EXCEPTION:
3093 
      x = TApplicationException()
3094 
      x.read(self._iprot)
3095 
      self._iprot.readMessageEnd()
3096 
      raise x
3097 
    result = updateWeight_result()
3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    if result.success is not None:
3101 
      return result.success
3102 
    if result.ex is not None:
3103 
      raise result.ex
3104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3105 
 
3469 chandransh 3106 
  def changeItem(self, orderId, itemId):
3107 
    """
3108 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3109 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3110 
 
3469 chandransh 3111 
    Parameters:
3112 
     - orderId
3113 
     - itemId
3114 
    """
3115 
    self.send_changeItem(orderId, itemId)
3116 
    return self.recv_changeItem()
3117 
 
3118 
  def send_changeItem(self, orderId, itemId):
3119 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3120 
    args = changeItem_args()
3121 
    args.orderId = orderId
3122 
    args.itemId = itemId
3123 
    args.write(self._oprot)
3124 
    self._oprot.writeMessageEnd()
3125 
    self._oprot.trans.flush()
3126 
 
3127 
  def recv_changeItem(self, ):
3128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3129 
    if mtype == TMessageType.EXCEPTION:
3130 
      x = TApplicationException()
3131 
      x.read(self._iprot)
3132 
      self._iprot.readMessageEnd()
3133 
      raise x
3134 
    result = changeItem_result()
3135 
    result.read(self._iprot)
3136 
    self._iprot.readMessageEnd()
3137 
    if result.success is not None:
3138 
      return result.success
3139 
    if result.ex is not None:
3140 
      raise result.ex
3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3142 
 
3143 
  def shiftToWarehouse(self, orderId, warehouseId):
3144 
    """
3145 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3146 
 
3147 
    Parameters:
3148 
     - orderId
3149 
     - warehouseId
3150 
    """
3151 
    self.send_shiftToWarehouse(orderId, warehouseId)
3152 
    return self.recv_shiftToWarehouse()
3153 
 
3154 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3155 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3156 
    args = shiftToWarehouse_args()
3157 
    args.orderId = orderId
3158 
    args.warehouseId = warehouseId
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_shiftToWarehouse(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = shiftToWarehouse_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3173 
    if result.success is not None:
3174 
      return result.success
3175 
    if result.ex is not None:
3176 
      raise result.ex
3177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3178 
 
4647 rajveer 3179 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3180 
    """
3181 
    Adds the given delay reason to the given order.
3986 chandransh 3182 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3183 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3184 
 
3553 chandransh 3185 
    Parameters:
3186 
     - orderId
3187 
     - delayReason
3986 chandransh 3188 
     - furtherDelay
4647 rajveer 3189 
     - delayReasonText
3553 chandransh 3190 
    """
4647 rajveer 3191 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3192 
    return self.recv_addDelayReason()
3193 
 
4647 rajveer 3194 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3195 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3196 
    args = addDelayReason_args()
3197 
    args.orderId = orderId
3198 
    args.delayReason = delayReason
3986 chandransh 3199 
    args.furtherDelay = furtherDelay
4647 rajveer 3200 
    args.delayReasonText = delayReasonText
3553 chandransh 3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_addDelayReason(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = addDelayReason_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
3217 
    if result.ex is not None:
3218 
      raise result.ex
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3220 
 
3956 chandransh 3221 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3222 
    """
3223 
    Marks the COD orders with given AWB nos. as having been processed.
3224 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3225 
 
3956 chandransh 3226 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3227 
    1. There is no order corresponding to an AWB number.
3228 
    2. The captured amount for a payment exceeds the total payment.
3229 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3230 
 
3231 
    Parameters:
3232 
     - collectedAmountMap
3233 
     - xferBy
3234 
     - xferTxnId
3235 
     - xferDate
3236 
    """
3237 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3238 
    return self.recv_reconcileCodCollection()
3239 
 
3240 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3241 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3242 
    args = reconcileCodCollection_args()
3243 
    args.collectedAmountMap = collectedAmountMap
3244 
    args.xferBy = xferBy
3245 
    args.xferTxnId = xferTxnId
3246 
    args.xferDate = xferDate
3247 
    args.write(self._oprot)
3248 
    self._oprot.writeMessageEnd()
3249 
    self._oprot.trans.flush()
3250 
 
3251 
  def recv_reconcileCodCollection(self, ):
3252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3253 
    if mtype == TMessageType.EXCEPTION:
3254 
      x = TApplicationException()
3255 
      x.read(self._iprot)
3256 
      self._iprot.readMessageEnd()
3257 
      raise x
3258 
    result = reconcileCodCollection_result()
3259 
    result.read(self._iprot)
3260 
    self._iprot.readMessageEnd()
3261 
    if result.success is not None:
3262 
      return result.success
3263 
    if result.ex is not None:
3264 
      raise result.ex
3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3266 
 
4008 mandeep.dh 3267 
  def getTransactionsRequiringExtraProcessing(self, category):
3268 
    """
4065 mandeep.dh 3269 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3270 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3271 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3272 
 
4008 mandeep.dh 3273 
    Parameters:
3274 
     - category
3275 
    """
3276 
    self.send_getTransactionsRequiringExtraProcessing(category)
3277 
    return self.recv_getTransactionsRequiringExtraProcessing()
3278 
 
3279 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3280 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3281 
    args = getTransactionsRequiringExtraProcessing_args()
3282 
    args.category = category
3283 
    args.write(self._oprot)
3284 
    self._oprot.writeMessageEnd()
3285 
    self._oprot.trans.flush()
3286 
 
3287 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3289 
    if mtype == TMessageType.EXCEPTION:
3290 
      x = TApplicationException()
3291 
      x.read(self._iprot)
3292 
      self._iprot.readMessageEnd()
3293 
      raise x
3294 
    result = getTransactionsRequiringExtraProcessing_result()
3295 
    result.read(self._iprot)
3296 
    self._iprot.readMessageEnd()
3297 
    if result.success is not None:
3298 
      return result.success
3299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3300 
 
3301 
  def markTransactionAsProcessed(self, transactionId, category):
3302 
    """
3303 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3304 
    It essentially deletes the transaction id record for a particular
3305 
    processing type category (if present) from DB.
3306 
    This is currently used by CRM application.
4008 mandeep.dh 3307 
 
3308 
    Parameters:
3309 
     - transactionId
3310 
     - category
3311 
    """
3312 
    self.send_markTransactionAsProcessed(transactionId, category)
3313 
    self.recv_markTransactionAsProcessed()
3314 
 
3315 
  def send_markTransactionAsProcessed(self, transactionId, category):
3316 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3317 
    args = markTransactionAsProcessed_args()
3318 
    args.transactionId = transactionId
3319 
    args.category = category
3320 
    args.write(self._oprot)
3321 
    self._oprot.writeMessageEnd()
3322 
    self._oprot.trans.flush()
3323 
 
3324 
  def recv_markTransactionAsProcessed(self, ):
3325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3326 
    if mtype == TMessageType.EXCEPTION:
3327 
      x = TApplicationException()
3328 
      x.read(self._iprot)
3329 
      self._iprot.readMessageEnd()
3330 
      raise x
3331 
    result = markTransactionAsProcessed_result()
3332 
    result.read(self._iprot)
3333 
    self._iprot.readMessageEnd()
3334 
    return
3335 
 
4018 chandransh 3336 
  def getItemWiseRiskyOrdersCount(self, ):
3337 
    """
3338 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3339 
    is defined as one whose shipping date is about to expire.
3340 
    """
3341 
    self.send_getItemWiseRiskyOrdersCount()
3342 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3343 
 
4018 chandransh 3344 
  def send_getItemWiseRiskyOrdersCount(self, ):
3345 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3346 
    args = getItemWiseRiskyOrdersCount_args()
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = getItemWiseRiskyOrdersCount_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3361 
    if result.success is not None:
3362 
      return result.success
3363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3364 
 
4295 varun.gupt 3365 
  def getOrdersForItemIds(self, itemIds):
3366 
    """
3367 
    Returns a list of all orders which have items with given id
3368 
 
3369 
    Parameters:
3370 
     - itemIds
3371 
    """
3372 
    self.send_getOrdersForItemIds(itemIds)
3373 
    return self.recv_getOrdersForItemIds()
3374 
 
3375 
  def send_getOrdersForItemIds(self, itemIds):
3376 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3377 
    args = getOrdersForItemIds_args()
3378 
    args.itemIds = itemIds
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getOrdersForItemIds(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getOrdersForItemIds_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3396 
 
4247 rajveer 3397 
  def markOrderCancellationRequestReceived(self, orderId):
3398 
    """
3399 
    Mark order as cancellation request received. If customer sends request of cancellation of
3400 
    a particular order, this method will be called. It will just change status of the order
3401 
    depending on its current status. It also records the previous status, so that we can move
3402 
    back to that status if cancellation request is denied.
4018 chandransh 3403 
 
4247 rajveer 3404 
    Parameters:
3405 
     - orderId
3406 
    """
3407 
    self.send_markOrderCancellationRequestReceived(orderId)
3408 
    self.recv_markOrderCancellationRequestReceived()
3409 
 
3410 
  def send_markOrderCancellationRequestReceived(self, orderId):
3411 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3412 
    args = markOrderCancellationRequestReceived_args()
3413 
    args.orderId = orderId
3414 
    args.write(self._oprot)
3415 
    self._oprot.writeMessageEnd()
3416 
    self._oprot.trans.flush()
3417 
 
3418 
  def recv_markOrderCancellationRequestReceived(self, ):
3419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3420 
    if mtype == TMessageType.EXCEPTION:
3421 
      x = TApplicationException()
3422 
      x.read(self._iprot)
3423 
      self._iprot.readMessageEnd()
3424 
      raise x
3425 
    result = markOrderCancellationRequestReceived_result()
3426 
    result.read(self._iprot)
3427 
    self._iprot.readMessageEnd()
3428 
    if result.ex is not None:
3429 
      raise result.ex
3430 
    return
3431 
 
3432 
  def markOrderCancellationRequestConfirmed(self, orderId):
3433 
    """
3434 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3435 
    cancellation request confirmed. After this OM will be able to cancel the order.
3436 
 
3437 
    Parameters:
3438 
     - orderId
3439 
    """
3440 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3441 
    self.recv_markOrderCancellationRequestConfirmed()
3442 
 
3443 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3444 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3445 
    args = markOrderCancellationRequestConfirmed_args()
3446 
    args.orderId = orderId
3447 
    args.write(self._oprot)
3448 
    self._oprot.writeMessageEnd()
3449 
    self._oprot.trans.flush()
3450 
 
3451 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3453 
    if mtype == TMessageType.EXCEPTION:
3454 
      x = TApplicationException()
3455 
      x.read(self._iprot)
3456 
      self._iprot.readMessageEnd()
3457 
      raise x
3458 
    result = markOrderCancellationRequestConfirmed_result()
3459 
    result.read(self._iprot)
3460 
    self._iprot.readMessageEnd()
3461 
    if result.ex is not None:
3462 
      raise result.ex
3463 
    return
3464 
 
3465 
  def markOrderCancellationRequestDenied(self, orderId):
3466 
    """
3467 
    If we decide to not to cancel order, we will move the order ro previous status.
3468 
 
3469 
    Parameters:
3470 
     - orderId
3471 
    """
3472 
    self.send_markOrderCancellationRequestDenied(orderId)
3473 
    self.recv_markOrderCancellationRequestDenied()
3474 
 
3475 
  def send_markOrderCancellationRequestDenied(self, orderId):
3476 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3477 
    args = markOrderCancellationRequestDenied_args()
3478 
    args.orderId = orderId
3479 
    args.write(self._oprot)
3480 
    self._oprot.writeMessageEnd()
3481 
    self._oprot.trans.flush()
3482 
 
3483 
  def recv_markOrderCancellationRequestDenied(self, ):
3484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3485 
    if mtype == TMessageType.EXCEPTION:
3486 
      x = TApplicationException()
3487 
      x.read(self._iprot)
3488 
      self._iprot.readMessageEnd()
3489 
      raise x
3490 
    result = markOrderCancellationRequestDenied_result()
3491 
    result.read(self._iprot)
3492 
    self._iprot.readMessageEnd()
3493 
    if result.ex is not None:
3494 
      raise result.ex
3495 
    return
3496 
 
4258 rajveer 3497 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3498 
    """
4258 rajveer 3499 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3500 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3501 
 
3502 
    Parameters:
4258 rajveer 3503 
     - transactionId
4247 rajveer 3504 
    """
4258 rajveer 3505 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3506 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3507 
 
4258 rajveer 3508 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3509 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3510 
    args = markTransactionAsPaymentFlagRemoved_args()
3511 
    args.transactionId = transactionId
4247 rajveer 3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
4258 rajveer 3516 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
4258 rajveer 3523 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.ex is not None:
3527 
      raise result.ex
3528 
    return
3529 
 
4259 anupam.sin 3530 
  def refundTransaction(self, transactionId, refundedBy, reason):
3531 
    """
3532 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3533 
    need to be cancelled
4247 rajveer 3534 
 
4259 anupam.sin 3535 
    Parameters:
3536 
     - transactionId
3537 
     - refundedBy
3538 
     - reason
3539 
    """
3540 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3541 
    self.recv_refundTransaction()
3542 
 
3543 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3544 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3545 
    args = refundTransaction_args()
3546 
    args.transactionId = transactionId
3547 
    args.refundedBy = refundedBy
3548 
    args.reason = reason
3549 
    args.write(self._oprot)
3550 
    self._oprot.writeMessageEnd()
3551 
    self._oprot.trans.flush()
3552 
 
3553 
  def recv_refundTransaction(self, ):
3554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3555 
    if mtype == TMessageType.EXCEPTION:
3556 
      x = TApplicationException()
3557 
      x.read(self._iprot)
3558 
      self._iprot.readMessageEnd()
3559 
      raise x
3560 
    result = refundTransaction_result()
3561 
    result.read(self._iprot)
3562 
    self._iprot.readMessageEnd()
3563 
    if result.ex is not None:
3564 
      raise result.ex
3565 
    return
3566 
 
4324 mandeep.dh 3567 
  def updateShipmentAddress(self, orderId, addressId):
3568 
    """
3569 
    Updates shipment address of an order. Delivery and shipping date estimates
3570 
    etc. are also updated here.
3571 
 
3572 
    Throws TransactionServiceException in case address change is not
3573 
    possible due to certain reasons such as new pincode in address is
3574 
    not serviceable etc.
3575 
 
3576 
    Parameters:
3577 
     - orderId
3578 
     - addressId
3579 
    """
3580 
    self.send_updateShipmentAddress(orderId, addressId)
3581 
    self.recv_updateShipmentAddress()
3582 
 
3583 
  def send_updateShipmentAddress(self, orderId, addressId):
3584 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3585 
    args = updateShipmentAddress_args()
3586 
    args.orderId = orderId
3587 
    args.addressId = addressId
3588 
    args.write(self._oprot)
3589 
    self._oprot.writeMessageEnd()
3590 
    self._oprot.trans.flush()
3591 
 
3592 
  def recv_updateShipmentAddress(self, ):
3593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3594 
    if mtype == TMessageType.EXCEPTION:
3595 
      x = TApplicationException()
3596 
      x.read(self._iprot)
3597 
      self._iprot.readMessageEnd()
3598 
      raise x
3599 
    result = updateShipmentAddress_result()
3600 
    result.read(self._iprot)
3601 
    self._iprot.readMessageEnd()
3602 
    if result.ex is not None:
3603 
      raise result.ex
3604 
    return
3605 
 
4285 rajveer 3606 
  def acceptOrdersForItemId(self, itemId, inventory):
3607 
    """
3608 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3609 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3610 
 
4285 rajveer 3611 
    Parameters:
3612 
     - itemId
3613 
     - inventory
3614 
    """
3615 
    self.send_acceptOrdersForItemId(itemId, inventory)
3616 
    return self.recv_acceptOrdersForItemId()
3617 
 
3618 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3619 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3620 
    args = acceptOrdersForItemId_args()
3621 
    args.itemId = itemId
3622 
    args.inventory = inventory
3623 
    args.write(self._oprot)
3624 
    self._oprot.writeMessageEnd()
3625 
    self._oprot.trans.flush()
3626 
 
3627 
  def recv_acceptOrdersForItemId(self, ):
3628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3629 
    if mtype == TMessageType.EXCEPTION:
3630 
      x = TApplicationException()
3631 
      x.read(self._iprot)
3632 
      self._iprot.readMessageEnd()
3633 
      raise x
3634 
    result = acceptOrdersForItemId_result()
3635 
    result.read(self._iprot)
3636 
    self._iprot.readMessageEnd()
3637 
    if result.success is not None:
3638 
      return result.success
3639 
    if result.ex is not None:
3640 
      raise result.ex
3641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3642 
 
4369 rajveer 3643 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3644 
    """
3645 
    Parameters:
3646 
     - vendorId
3647 
     - itemId
3648 
     - quantity
3649 
     - estimate
4369 rajveer 3650 
     - isReminder
4303 rajveer 3651 
    """
4369 rajveer 3652 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3653 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3654 
 
4369 rajveer 3655 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3656 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3657 
    args = markOrdersAsPORaised_args()
3658 
    args.vendorId = vendorId
3659 
    args.itemId = itemId
3660 
    args.quantity = quantity
3661 
    args.estimate = estimate
4369 rajveer 3662 
    args.isReminder = isReminder
4303 rajveer 3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_markOrdersAsPORaised(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = markOrdersAsPORaised_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.ex is not None:
3678 
      raise result.ex
3679 
    return
3680 
 
4369 rajveer 3681 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3682 
    """
3683 
    Parameters:
3684 
     - vendorId
3685 
     - itemId
3686 
     - quantity
3687 
     - estimate
4369 rajveer 3688 
     - isReminder
4303 rajveer 3689 
    """
4369 rajveer 3690 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3691 
    self.recv_markOrdersAsReversalInitiated()
3692 
 
4369 rajveer 3693 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3694 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3695 
    args = markOrdersAsReversalInitiated_args()
3696 
    args.vendorId = vendorId
3697 
    args.itemId = itemId
3698 
    args.quantity = quantity
3699 
    args.estimate = estimate
4369 rajveer 3700 
    args.isReminder = isReminder
4303 rajveer 3701 
    args.write(self._oprot)
3702 
    self._oprot.writeMessageEnd()
3703 
    self._oprot.trans.flush()
3704 
 
3705 
  def recv_markOrdersAsReversalInitiated(self, ):
3706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3707 
    if mtype == TMessageType.EXCEPTION:
3708 
      x = TApplicationException()
3709 
      x.read(self._iprot)
3710 
      self._iprot.readMessageEnd()
3711 
      raise x
3712 
    result = markOrdersAsReversalInitiated_result()
3713 
    result.read(self._iprot)
3714 
    self._iprot.readMessageEnd()
3715 
    if result.ex is not None:
3716 
      raise result.ex
3717 
    return
3718 
 
4369 rajveer 3719 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3720 
    """
3721 
    Parameters:
3722 
     - vendorId
3723 
     - itemId
3724 
     - quantity
3725 
     - estimate
4369 rajveer 3726 
     - isReminder
4303 rajveer 3727 
    """
4369 rajveer 3728 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3729 
    self.recv_markOrdersAsNotAvailabke()
3730 
 
4369 rajveer 3731 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3732 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3733 
    args = markOrdersAsNotAvailabke_args()
3734 
    args.vendorId = vendorId
3735 
    args.itemId = itemId
3736 
    args.quantity = quantity
3737 
    args.estimate = estimate
4369 rajveer 3738 
    args.isReminder = isReminder
4303 rajveer 3739 
    args.write(self._oprot)
3740 
    self._oprot.writeMessageEnd()
3741 
    self._oprot.trans.flush()
3742 
 
3743 
  def recv_markOrdersAsNotAvailabke(self, ):
3744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3745 
    if mtype == TMessageType.EXCEPTION:
3746 
      x = TApplicationException()
3747 
      x.read(self._iprot)
3748 
      self._iprot.readMessageEnd()
3749 
      raise x
3750 
    result = markOrdersAsNotAvailabke_result()
3751 
    result.read(self._iprot)
3752 
    self._iprot.readMessageEnd()
3753 
    if result.ex is not None:
3754 
      raise result.ex
3755 
    return
3756 
 
4369 rajveer 3757 
  def markOrdersAsTimeout(self, vendorId):
3758 
    """
3759 
    Parameters:
3760 
     - vendorId
3761 
    """
3762 
    self.send_markOrdersAsTimeout(vendorId)
3763 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3764 
 
4369 rajveer 3765 
  def send_markOrdersAsTimeout(self, vendorId):
3766 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3767 
    args = markOrdersAsTimeout_args()
3768 
    args.vendorId = vendorId
3769 
    args.write(self._oprot)
3770 
    self._oprot.writeMessageEnd()
3771 
    self._oprot.trans.flush()
3772 
 
3773 
  def recv_markOrdersAsTimeout(self, ):
3774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3775 
    if mtype == TMessageType.EXCEPTION:
3776 
      x = TApplicationException()
3777 
      x.read(self._iprot)
3778 
      self._iprot.readMessageEnd()
3779 
      raise x
3780 
    result = markOrdersAsTimeout_result()
3781 
    result.read(self._iprot)
3782 
    self._iprot.readMessageEnd()
3783 
    if result.success is not None:
3784 
      return result.success
3785 
    if result.ex is not None:
3786 
      raise result.ex
3787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3788 
 
4386 anupam.sin 3789 
  def getOrderForAwb(self, awb):
3790 
    """
3791 
    Returns the order corresponding to an AWB number
4369 rajveer 3792 
 
4386 anupam.sin 3793 
    Parameters:
3794 
     - awb
3795 
    """
3796 
    self.send_getOrderForAwb(awb)
3797 
    return self.recv_getOrderForAwb()
3798 
 
3799 
  def send_getOrderForAwb(self, awb):
3800 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3801 
    args = getOrderForAwb_args()
3802 
    args.awb = awb
3803 
    args.write(self._oprot)
3804 
    self._oprot.writeMessageEnd()
3805 
    self._oprot.trans.flush()
3806 
 
3807 
  def recv_getOrderForAwb(self, ):
3808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3809 
    if mtype == TMessageType.EXCEPTION:
3810 
      x = TApplicationException()
3811 
      x.read(self._iprot)
3812 
      self._iprot.readMessageEnd()
3813 
      raise x
3814 
    result = getOrderForAwb_result()
3815 
    result.read(self._iprot)
3816 
    self._iprot.readMessageEnd()
3817 
    if result.success is not None:
3818 
      return result.success
3819 
    if result.ex is not None:
3820 
      raise result.ex
3821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3822 
 
4506 phani.kuma 3823 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3824 
    """
3825 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3826 
 
4506 phani.kuma 3827 
    Parameters:
3828 
     - logistics_provider_id
3829 
     - order_status
3830 
    """
3831 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3832 
    return self.recv_getOrdersForProviderForStatus()
3833 
 
3834 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3835 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3836 
    args = getOrdersForProviderForStatus_args()
3837 
    args.logistics_provider_id = logistics_provider_id
3838 
    args.order_status = order_status
3839 
    args.write(self._oprot)
3840 
    self._oprot.writeMessageEnd()
3841 
    self._oprot.trans.flush()
3842 
 
3843 
  def recv_getOrdersForProviderForStatus(self, ):
3844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3845 
    if mtype == TMessageType.EXCEPTION:
3846 
      x = TApplicationException()
3847 
      x.read(self._iprot)
3848 
      self._iprot.readMessageEnd()
3849 
      raise x
3850 
    result = getOrdersForProviderForStatus_result()
3851 
    result.read(self._iprot)
3852 
    self._iprot.readMessageEnd()
3853 
    if result.success is not None:
3854 
      return result.success
3855 
    if result.ex is not None:
3856 
      raise result.ex
3857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3858 
 
4600 varun.gupt 3859 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3860 
    """
3861 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3862 
 
4600 varun.gupt 3863 
    Parameters:
3864 
     - vendorId
3865 
     - billingDateFrom
3866 
     - billingDateTo
3867 
    """
3868 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3869 
    return self.recv_getBilledOrdersForVendor()
3870 
 
3871 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3872 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3873 
    args = getBilledOrdersForVendor_args()
3874 
    args.vendorId = vendorId
3875 
    args.billingDateFrom = billingDateFrom
3876 
    args.billingDateTo = billingDateTo
3877 
    args.write(self._oprot)
3878 
    self._oprot.writeMessageEnd()
3879 
    self._oprot.trans.flush()
3880 
 
3881 
  def recv_getBilledOrdersForVendor(self, ):
3882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3883 
    if mtype == TMessageType.EXCEPTION:
3884 
      x = TApplicationException()
3885 
      x.read(self._iprot)
3886 
      self._iprot.readMessageEnd()
3887 
      raise x
3888 
    result = getBilledOrdersForVendor_result()
3889 
    result.read(self._iprot)
3890 
    self._iprot.readMessageEnd()
3891 
    if result.success is not None:
3892 
      return result.success
3893 
    if result.ex is not None:
3894 
      raise result.ex
3895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3896 
 
4607 rajveer 3897 
  def getSlippedSippingDateOrders(self, ):
3898 
    self.send_getSlippedSippingDateOrders()
3899 
    return self.recv_getSlippedSippingDateOrders()
3900 
 
3901 
  def send_getSlippedSippingDateOrders(self, ):
3902 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
3903 
    args = getSlippedSippingDateOrders_args()
3904 
    args.write(self._oprot)
3905 
    self._oprot.writeMessageEnd()
3906 
    self._oprot.trans.flush()
3907 
 
3908 
  def recv_getSlippedSippingDateOrders(self, ):
3909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3910 
    if mtype == TMessageType.EXCEPTION:
3911 
      x = TApplicationException()
3912 
      x.read(self._iprot)
3913 
      self._iprot.readMessageEnd()
3914 
      raise x
3915 
    result = getSlippedSippingDateOrders_result()
3916 
    result.read(self._iprot)
3917 
    self._iprot.readMessageEnd()
3918 
    if result.success is not None:
3919 
      return result.success
3920 
    if result.ex is not None:
3921 
      raise result.ex
3922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
3923 
 
4600 varun.gupt 3924 
  def saveBluedartSettlements(self, mapAWBAndAmount):
3925 
    """
3926 
    Parameters:
3927 
     - mapAWBAndAmount
3928 
    """
3929 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
3930 
    self.recv_saveBluedartSettlements()
3931 
 
3932 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
3933 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
3934 
    args = saveBluedartSettlements_args()
3935 
    args.mapAWBAndAmount = mapAWBAndAmount
3936 
    args.write(self._oprot)
3937 
    self._oprot.writeMessageEnd()
3938 
    self._oprot.trans.flush()
3939 
 
3940 
  def recv_saveBluedartSettlements(self, ):
3941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3942 
    if mtype == TMessageType.EXCEPTION:
3943 
      x = TApplicationException()
3944 
      x.read(self._iprot)
3945 
      self._iprot.readMessageEnd()
3946 
      raise x
3947 
    result = saveBluedartSettlements_result()
3948 
    result.read(self._iprot)
3949 
    self._iprot.readMessageEnd()
3950 
    if result.ex is not None:
3951 
      raise result.ex
3952 
    return
3953 
 
3954 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3955 
    """
3956 
    Parameters:
3957 
     - settlementDate
3958 
     - paymentGatewayId
3959 
     - paymentId
3960 
     - serviceTax
3961 
     - otherCharges
3962 
     - netCollection
3963 
    """
3964 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
3965 
    self.recv_savePaymentSettlements()
3966 
 
3967 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3968 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
3969 
    args = savePaymentSettlements_args()
3970 
    args.settlementDate = settlementDate
3971 
    args.paymentGatewayId = paymentGatewayId
3972 
    args.paymentId = paymentId
3973 
    args.serviceTax = serviceTax
3974 
    args.otherCharges = otherCharges
3975 
    args.netCollection = netCollection
3976 
    args.write(self._oprot)
3977 
    self._oprot.writeMessageEnd()
3978 
    self._oprot.trans.flush()
3979 
 
3980 
  def recv_savePaymentSettlements(self, ):
3981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3982 
    if mtype == TMessageType.EXCEPTION:
3983 
      x = TApplicationException()
3984 
      x.read(self._iprot)
3985 
      self._iprot.readMessageEnd()
3986 
      raise x
3987 
    result = savePaymentSettlements_result()
3988 
    result.read(self._iprot)
3989 
    self._iprot.readMessageEnd()
3990 
    if result.ex is not None:
3991 
      raise result.ex
3992 
    return
3993 
 
3994 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3995 
    """
3996 
    Parameters:
3997 
     - settlementId
3998 
     - settlementDate
3999 
     - transactionDateFrom
4000 
     - transactionDateTo
4001 
     - amount
4002 
    """
4003 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4004 
    self.recv_saveEBSSettlementSummary()
4005 
 
4006 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4007 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4008 
    args = saveEBSSettlementSummary_args()
4009 
    args.settlementId = settlementId
4010 
    args.settlementDate = settlementDate
4011 
    args.transactionDateFrom = transactionDateFrom
4012 
    args.transactionDateTo = transactionDateTo
4013 
    args.amount = amount
4014 
    args.write(self._oprot)
4015 
    self._oprot.writeMessageEnd()
4016 
    self._oprot.trans.flush()
4017 
 
4018 
  def recv_saveEBSSettlementSummary(self, ):
4019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4020 
    if mtype == TMessageType.EXCEPTION:
4021 
      x = TApplicationException()
4022 
      x.read(self._iprot)
4023 
      self._iprot.readMessageEnd()
4024 
      raise x
4025 
    result = saveEBSSettlementSummary_result()
4026 
    result.read(self._iprot)
4027 
    self._iprot.readMessageEnd()
4028 
    if result.ex is not None:
4029 
      raise result.ex
4030 
    return
4031 
 
4032 
  def getSettlementForPaymentId(self, paymentId):
4033 
    """
4034 
    Parameters:
4035 
     - paymentId
4036 
    """
4037 
    self.send_getSettlementForPaymentId(paymentId)
4038 
    return self.recv_getSettlementForPaymentId()
4039 
 
4040 
  def send_getSettlementForPaymentId(self, paymentId):
4041 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4042 
    args = getSettlementForPaymentId_args()
4043 
    args.paymentId = paymentId
4044 
    args.write(self._oprot)
4045 
    self._oprot.writeMessageEnd()
4046 
    self._oprot.trans.flush()
4047 
 
4048 
  def recv_getSettlementForPaymentId(self, ):
4049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4050 
    if mtype == TMessageType.EXCEPTION:
4051 
      x = TApplicationException()
4052 
      x.read(self._iprot)
4053 
      self._iprot.readMessageEnd()
4054 
      raise x
4055 
    result = getSettlementForPaymentId_result()
4056 
    result.read(self._iprot)
4057 
    self._iprot.readMessageEnd()
4058 
    if result.success is not None:
4059 
      return result.success
4060 
    if result.ex is not None:
4061 
      raise result.ex
4062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4063 
 
4064 
  def getEBSSettlementSummaries(self, ):
4065 
    self.send_getEBSSettlementSummaries()
4066 
    return self.recv_getEBSSettlementSummaries()
4067 
 
4068 
  def send_getEBSSettlementSummaries(self, ):
4069 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4070 
    args = getEBSSettlementSummaries_args()
4071 
    args.write(self._oprot)
4072 
    self._oprot.writeMessageEnd()
4073 
    self._oprot.trans.flush()
4074 
 
4075 
  def recv_getEBSSettlementSummaries(self, ):
4076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4077 
    if mtype == TMessageType.EXCEPTION:
4078 
      x = TApplicationException()
4079 
      x.read(self._iprot)
4080 
      self._iprot.readMessageEnd()
4081 
      raise x
4082 
    result = getEBSSettlementSummaries_result()
4083 
    result.read(self._iprot)
4084 
    self._iprot.readMessageEnd()
4085 
    if result.success is not None:
4086 
      return result.success
4087 
    if result.ex is not None:
4088 
      raise result.ex
4089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4090 
 
4091 
  def markEBSSettlementUploaded(self, settlementId):
4092 
    """
4093 
    Parameters:
4094 
     - settlementId
4095 
    """
4096 
    self.send_markEBSSettlementUploaded(settlementId)
4097 
    self.recv_markEBSSettlementUploaded()
4098 
 
4099 
  def send_markEBSSettlementUploaded(self, settlementId):
4100 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4101 
    args = markEBSSettlementUploaded_args()
4102 
    args.settlementId = settlementId
4103 
    args.write(self._oprot)
4104 
    self._oprot.writeMessageEnd()
4105 
    self._oprot.trans.flush()
4106 
 
4107 
  def recv_markEBSSettlementUploaded(self, ):
4108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4109 
    if mtype == TMessageType.EXCEPTION:
4110 
      x = TApplicationException()
4111 
      x.read(self._iprot)
4112 
      self._iprot.readMessageEnd()
4113 
      raise x
4114 
    result = markEBSSettlementUploaded_result()
4115 
    result.read(self._iprot)
4116 
    self._iprot.readMessageEnd()
4117 
    if result.ex is not None:
4118 
      raise result.ex
4119 
    return
4120 
 
4121 
  def getEBSSettlementDate(self, settlementId):
4122 
    """
4123 
    Parameters:
4124 
     - settlementId
4125 
    """
4126 
    self.send_getEBSSettlementDate(settlementId)
4127 
    return self.recv_getEBSSettlementDate()
4128 
 
4129 
  def send_getEBSSettlementDate(self, settlementId):
4130 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4131 
    args = getEBSSettlementDate_args()
4132 
    args.settlementId = settlementId
4133 
    args.write(self._oprot)
4134 
    self._oprot.writeMessageEnd()
4135 
    self._oprot.trans.flush()
4136 
 
4137 
  def recv_getEBSSettlementDate(self, ):
4138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4139 
    if mtype == TMessageType.EXCEPTION:
4140 
      x = TApplicationException()
4141 
      x.read(self._iprot)
4142 
      self._iprot.readMessageEnd()
4143 
      raise x
4144 
    result = getEBSSettlementDate_result()
4145 
    result.read(self._iprot)
4146 
    self._iprot.readMessageEnd()
4147 
    if result.success is not None:
4148 
      return result.success
4149 
    if result.ex is not None:
4150 
      raise result.ex
4151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4152 
 
4153 
 
3376 rajveer 4154 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4155 
  def __init__(self, handler):
3376 rajveer 4156 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4157 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4158 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4159 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4160 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4161 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4162 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4163 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4164 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4165 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4166 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4167 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4168 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4169 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4170 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4171 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4172 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4173 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4174 
    self._processMap["createOrder"] = Processor.process_createOrder
4175 
    self._processMap["getOrder"] = Processor.process_getOrder
4176 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4177 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4178 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4179 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4180 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4181 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4182 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4183 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4184 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4185 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4186 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4187 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4188 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4189 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4190 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4191 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4192 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4193 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4194 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4195 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4196 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4197 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4198 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4199 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4200 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4201 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4202 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4203 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4204 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4205 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4206 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4207 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4208 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4209 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4210 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4211 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4212 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4213 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4214 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4215 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4216 
    self._processMap["changeItem"] = Processor.process_changeItem
4217 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4218 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4219 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4220 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4221 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4222 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4223 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4224 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4225 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4226 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4227 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4228 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4229 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4230 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4231 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4232 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4233 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4234 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 4235 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4236 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4237 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4238 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4600 varun.gupt 4239 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4240 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4241 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4242 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4243 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4244 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4245 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4246 
 
4247 
  def process(self, iprot, oprot):
4248 
    (name, type, seqid) = iprot.readMessageBegin()
4249 
    if name not in self._processMap:
4250 
      iprot.skip(TType.STRUCT)
4251 
      iprot.readMessageEnd()
4252 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4253 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4254 
      x.write(oprot)
4255 
      oprot.writeMessageEnd()
4256 
      oprot.trans.flush()
4257 
      return
4258 
    else:
4259 
      self._processMap[name](self, seqid, iprot, oprot)
4260 
    return True
4261 
 
4262 
  def process_createTransaction(self, seqid, iprot, oprot):
4263 
    args = createTransaction_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = createTransaction_result()
4267 
    try:
132 ashish 4268 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4269 
    except TransactionServiceException, ex:
4270 
      result.ex = ex
4271 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
4276 
  def process_getTransaction(self, seqid, iprot, oprot):
4277 
    args = getTransaction_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = getTransaction_result()
4281 
    try:
4282 
      result.success = self._handler.getTransaction(args.id)
4283 
    except TransactionServiceException, ex:
4284 
      result.ex = ex
4285 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
4289 
 
4290 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4291 
    args = getTransactionsForCustomer_args()
4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4294 
    result = getTransactionsForCustomer_result()
4295 
    try:
4296 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4297 
    except TransactionServiceException, ex:
4298 
      result.ex = ex
4299 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
4303 
 
132 ashish 4304 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4305 
    args = getTransactionsForShoppingCartId_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = getTransactionsForShoppingCartId_result()
4309 
    try:
4310 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4311 
    except TransactionServiceException, ex:
4312 
      result.ex = ex
4313 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4314 
    result.write(oprot)
4315 
    oprot.writeMessageEnd()
4316 
    oprot.trans.flush()
4317 
 
94 ashish 4318 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4319 
    args = getTransactionStatus_args()
4320 
    args.read(iprot)
4321 
    iprot.readMessageEnd()
4322 
    result = getTransactionStatus_result()
4323 
    try:
4324 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4325 
    except TransactionServiceException, ex:
4326 
      result.ex = ex
4327 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
4331 
 
4332 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4333 
    args = changeTransactionStatus_args()
4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
4336 
    result = changeTransactionStatus_result()
4337 
    try:
4338 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4339 
    except TransactionServiceException, ex:
4340 
      result.ex = ex
4341 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
4345 
 
1398 varun.gupt 4346 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4347 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
1398 varun.gupt 4350 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4351 
    try:
1398 varun.gupt 4352 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4353 
    except TransactionServiceException, ex:
4354 
      result.ex = ex
1398 varun.gupt 4355 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
483 rajveer 4360 
  def process_getAllOrders(self, seqid, iprot, oprot):
4361 
    args = getAllOrders_args()
94 ashish 4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
483 rajveer 4364 
    result = getAllOrders_result()
94 ashish 4365 
    try:
483 rajveer 4366 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4367 
    except TransactionServiceException, ex:
4368 
      result.ex = ex
483 rajveer 4369 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4133 chandransh 4374 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4375 
    args = getOrdersInBatch_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = getOrdersInBatch_result()
4379 
    try:
4380 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4381 
    except TransactionServiceException, ex:
4382 
      result.ex = ex
4383 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4384 
    result.write(oprot)
4385 
    oprot.writeMessageEnd()
4386 
    oprot.trans.flush()
4387 
 
4388 
  def process_getOrderCount(self, seqid, iprot, oprot):
4389 
    args = getOrderCount_args()
4390 
    args.read(iprot)
4391 
    iprot.readMessageEnd()
4392 
    result = getOrderCount_result()
4393 
    try:
4394 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4395 
    except TransactionServiceException, ex:
4396 
      result.ex = ex
4397 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
4401 
 
999 varun.gupt 4402 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4403 
    args = getOrdersByBillingDate_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = getOrdersByBillingDate_result()
4407 
    try:
4408 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4409 
    except TransactionServiceException, ex:
4410 
      result.ex = ex
4411 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4412 
    result.write(oprot)
4413 
    oprot.writeMessageEnd()
4414 
    oprot.trans.flush()
4415 
 
3427 chandransh 4416 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4417 
    args = getOrdersByShippingDate_args()
4418 
    args.read(iprot)
4419 
    iprot.readMessageEnd()
4420 
    result = getOrdersByShippingDate_result()
4421 
    try:
3451 chandransh 4422 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4423 
    except TransactionServiceException, ex:
4424 
      result.ex = ex
4425 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4426 
    result.write(oprot)
4427 
    oprot.writeMessageEnd()
4428 
    oprot.trans.flush()
4429 
 
1382 varun.gupt 4430 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4431 
    args = getReturnableOrdersForCustomer_args()
4432 
    args.read(iprot)
4433 
    iprot.readMessageEnd()
4434 
    result = getReturnableOrdersForCustomer_result()
4435 
    try:
4436 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4437 
    except TransactionServiceException, ex:
4438 
      result.ex = ex
4439 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
4443 
 
4444 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4445 
    args = getCancellableOrdersForCustomer_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getCancellableOrdersForCustomer_result()
4449 
    try:
4450 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4451 
    except TransactionServiceException, ex:
4452 
      result.ex = ex
4453 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4454 
    result.write(oprot)
4455 
    oprot.writeMessageEnd()
4456 
    oprot.trans.flush()
4457 
 
483 rajveer 4458 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4459 
    args = changeOrderStatus_args()
94 ashish 4460 
    args.read(iprot)
4461 
    iprot.readMessageEnd()
483 rajveer 4462 
    result = changeOrderStatus_result()
94 ashish 4463 
    try:
483 rajveer 4464 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4465 
    except TransactionServiceException, ex:
4466 
      result.ex = ex
483 rajveer 4467 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4468 
    result.write(oprot)
4469 
    oprot.writeMessageEnd()
4470 
    oprot.trans.flush()
4471 
 
483 rajveer 4472 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4473 
    args = getOrdersForTransaction_args()
94 ashish 4474 
    args.read(iprot)
4475 
    iprot.readMessageEnd()
483 rajveer 4476 
    result = getOrdersForTransaction_result()
94 ashish 4477 
    try:
1528 ankur.sing 4478 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4479 
    except TransactionServiceException, ex:
4480 
      result.ex = ex
483 rajveer 4481 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4482 
    result.write(oprot)
4483 
    oprot.writeMessageEnd()
4484 
    oprot.trans.flush()
4485 
 
483 rajveer 4486 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4487 
    args = getOrdersForCustomer_args()
94 ashish 4488 
    args.read(iprot)
4489 
    iprot.readMessageEnd()
483 rajveer 4490 
    result = getOrdersForCustomer_result()
94 ashish 4491 
    try:
3014 chandransh 4492 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4493 
    except TransactionServiceException, ex:
4494 
      result.ex = ex
483 rajveer 4495 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4496 
    result.write(oprot)
4497 
    oprot.writeMessageEnd()
4498 
    oprot.trans.flush()
4499 
 
483 rajveer 4500 
  def process_createOrder(self, seqid, iprot, oprot):
4501 
    args = createOrder_args()
94 ashish 4502 
    args.read(iprot)
4503 
    iprot.readMessageEnd()
483 rajveer 4504 
    result = createOrder_result()
94 ashish 4505 
    try:
483 rajveer 4506 
      result.success = self._handler.createOrder(args.order)
94 ashish 4507 
    except TransactionServiceException, ex:
4508 
      result.ex = ex
483 rajveer 4509 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4510 
    result.write(oprot)
4511 
    oprot.writeMessageEnd()
4512 
    oprot.trans.flush()
4513 
 
483 rajveer 4514 
  def process_getOrder(self, seqid, iprot, oprot):
4515 
    args = getOrder_args()
94 ashish 4516 
    args.read(iprot)
4517 
    iprot.readMessageEnd()
483 rajveer 4518 
    result = getOrder_result()
94 ashish 4519 
    try:
483 rajveer 4520 
      result.success = self._handler.getOrder(args.id)
94 ashish 4521 
    except TransactionServiceException, ex:
4522 
      result.ex = ex
483 rajveer 4523 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4524 
    result.write(oprot)
4525 
    oprot.writeMessageEnd()
4526 
    oprot.trans.flush()
4527 
 
483 rajveer 4528 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4529 
    args = getLineItemsForOrder_args()
94 ashish 4530 
    args.read(iprot)
4531 
    iprot.readMessageEnd()
483 rajveer 4532 
    result = getLineItemsForOrder_result()
94 ashish 4533 
    try:
483 rajveer 4534 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4535 
    except TransactionServiceException, ex:
4536 
      result.ex = ex
483 rajveer 4537 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
1528 ankur.sing 4542 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4543 
    args = getOrderForCustomer_args()
4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
4546 
    result = getOrderForCustomer_result()
4547 
    try:
4548 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4549 
    except TransactionServiceException, ex:
4550 
      result.ex = ex
4551 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4552 
    result.write(oprot)
4553 
    oprot.writeMessageEnd()
4554 
    oprot.trans.flush()
4555 
 
3064 chandransh 4556 
  def process_getAlerts(self, seqid, iprot, oprot):
4557 
    args = getAlerts_args()
4558 
    args.read(iprot)
4559 
    iprot.readMessageEnd()
4560 
    result = getAlerts_result()
4444 rajveer 4561 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4562 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4563 
    result.write(oprot)
4564 
    oprot.writeMessageEnd()
4565 
    oprot.trans.flush()
4566 
 
4394 rajveer 4567 
  def process_addAlert(self, seqid, iprot, oprot):
4568 
    args = addAlert_args()
3064 chandransh 4569 
    args.read(iprot)
4570 
    iprot.readMessageEnd()
4394 rajveer 4571 
    result = addAlert_result()
4444 rajveer 4572 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4573 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4574 
    result.write(oprot)
4575 
    oprot.writeMessageEnd()
4576 
    oprot.trans.flush()
4577 
 
4444 rajveer 4578 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4579 
    args = markAlertsAsSeen_args()
4580 
    args.read(iprot)
4581 
    iprot.readMessageEnd()
4582 
    result = markAlertsAsSeen_result()
4583 
    self._handler.markAlertsAsSeen(args.warehouseId)
4584 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4585 
    result.write(oprot)
4586 
    oprot.writeMessageEnd()
4587 
    oprot.trans.flush()
4588 
 
3064 chandransh 4589 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4590 
    args = getValidOrderCount_args()
4591 
    args.read(iprot)
4592 
    iprot.readMessageEnd()
4593 
    result = getValidOrderCount_result()
4594 
    result.success = self._handler.getValidOrderCount()
4595 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4599 
 
4600 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4601 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4605 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4606 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4612 
    args = getValidOrdersAmountRange_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = getValidOrdersAmountRange_result()
4616 
    result.success = self._handler.getValidOrdersAmountRange()
4617 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
4622 
  def process_getValidOrders(self, seqid, iprot, oprot):
4623 
    args = getValidOrders_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getValidOrders_result()
4627 
    result.success = self._handler.getValidOrders(args.limit)
4628 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
1220 chandransh 4633 
  def process_batchOrders(self, seqid, iprot, oprot):
4634 
    args = batchOrders_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = batchOrders_result()
4638 
    try:
4639 
      result.success = self._handler.batchOrders(args.warehouseId)
4640 
    except TransactionServiceException, ex:
4641 
      result.ex = ex
4642 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4643 
    result.write(oprot)
4644 
    oprot.writeMessageEnd()
4645 
    oprot.trans.flush()
4646 
 
1208 chandransh 4647 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4648 
    args = markOrderAsOutOfStock_args()
4649 
    args.read(iprot)
4650 
    iprot.readMessageEnd()
4651 
    result = markOrderAsOutOfStock_result()
4652 
    try:
4653 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4654 
    except TransactionServiceException, ex:
4655 
      result.ex = ex
4656 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4657 
    result.write(oprot)
4658 
    oprot.writeMessageEnd()
4659 
    oprot.trans.flush()
4660 
 
3064 chandransh 4661 
  def process_verifyOrder(self, seqid, iprot, oprot):
4662 
    args = verifyOrder_args()
759 chandransh 4663 
    args.read(iprot)
4664 
    iprot.readMessageEnd()
3064 chandransh 4665 
    result = verifyOrder_result()
759 chandransh 4666 
    try:
3064 chandransh 4667 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4668 
    except TransactionServiceException, ex:
4669 
      result.ex = ex
3064 chandransh 4670 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4671 
    result.write(oprot)
4672 
    oprot.writeMessageEnd()
4673 
    oprot.trans.flush()
4674 
 
3064 chandransh 4675 
  def process_acceptOrder(self, seqid, iprot, oprot):
4676 
    args = acceptOrder_args()
1113 chandransh 4677 
    args.read(iprot)
4678 
    iprot.readMessageEnd()
3064 chandransh 4679 
    result = acceptOrder_result()
1113 chandransh 4680 
    try:
3064 chandransh 4681 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4682 
    except TransactionServiceException, ex:
4683 
      result.ex = ex
3064 chandransh 4684 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4685 
    result.write(oprot)
4686 
    oprot.writeMessageEnd()
4687 
    oprot.trans.flush()
4688 
 
3064 chandransh 4689 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4690 
    args = addBillingDetails_args()
1135 chandransh 4691 
    args.read(iprot)
4692 
    iprot.readMessageEnd()
3064 chandransh 4693 
    result = addBillingDetails_result()
1135 chandransh 4694 
    try:
4283 anupam.sin 4695 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.imeiNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4696 
    except TransactionServiceException, ex:
4697 
      result.ex = ex
3064 chandransh 4698 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4699 
    result.write(oprot)
4700 
    oprot.writeMessageEnd()
4701 
    oprot.trans.flush()
4702 
 
4579 rajveer 4703 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4704 
    args = addInvoiceNumber_args()
4705 
    args.read(iprot)
4706 
    iprot.readMessageEnd()
4707 
    result = addInvoiceNumber_result()
4708 
    try:
4709 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4710 
    except TransactionServiceException, ex:
4711 
      result.ex = ex
4712 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4713 
    result.write(oprot)
4714 
    oprot.writeMessageEnd()
4715 
    oprot.trans.flush()
4716 
 
3064 chandransh 4717 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4718 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4719 
    args.read(iprot)
4720 
    iprot.readMessageEnd()
3064 chandransh 4721 
    result = markOrdersAsManifested_result()
4722 
    try:
4723 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4724 
    except TransactionServiceException, ex:
4725 
      result.ex = ex
4726 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
4410 rajveer 4731 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4732 
    args = markOrdersAsShippedFromWarehouse_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = markOrdersAsShippedFromWarehouse_result()
4736 
    try:
4737 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4738 
    except TransactionServiceException, ex:
4739 
      result.ex = ex
4740 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4741 
    result.write(oprot)
4742 
    oprot.writeMessageEnd()
4743 
    oprot.trans.flush()
4744 
 
3064 chandransh 4745 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4746 
    args = markOrdersAsPickedUp_args()
304 ashish 4747 
    args.read(iprot)
4748 
    iprot.readMessageEnd()
3064 chandransh 4749 
    result = markOrdersAsPickedUp_result()
4750 
    try:
4751 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4752 
    except TransactionServiceException, ex:
4753 
      result.ex = ex
4754 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
94 ashish 4758 
 
3064 chandransh 4759 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4760 
    args = markOrdersAsDelivered_args()
304 ashish 4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
3064 chandransh 4763 
    result = markOrdersAsDelivered_result()
4764 
    try:
4765 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4766 
    except TransactionServiceException, ex:
4767 
      result.ex = ex
4768 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4769 
    result.write(oprot)
4770 
    oprot.writeMessageEnd()
4771 
    oprot.trans.flush()
4772 
 
3064 chandransh 4773 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4774 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4775 
    args.read(iprot)
4776 
    iprot.readMessageEnd()
3064 chandransh 4777 
    result = markOrdersAsFailed_result()
4778 
    try:
4779 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4780 
    except TransactionServiceException, ex:
4781 
      result.ex = ex
4782 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4783 
    result.write(oprot)
4784 
    oprot.writeMessageEnd()
4785 
    oprot.trans.flush()
304 ashish 4786 
 
3064 chandransh 4787 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4788 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4789 
    args.read(iprot)
4790 
    iprot.readMessageEnd()
3064 chandransh 4791 
    result = updateNonDeliveryReason_result()
4792 
    try:
4581 phani.kuma 4793 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4794 
    except TransactionServiceException, ex:
4795 
      result.ex = ex
4796 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4797 
    result.write(oprot)
4798 
    oprot.writeMessageEnd()
4799 
    oprot.trans.flush()
1596 ankur.sing 4800 
 
3064 chandransh 4801 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4802 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4803 
    args.read(iprot)
4804 
    iprot.readMessageEnd()
3064 chandransh 4805 
    result = getUndeliveredOrders_result()
4806 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4807 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4808 
    result.write(oprot)
4809 
    oprot.writeMessageEnd()
4810 
    oprot.trans.flush()
4811 
 
2536 chandransh 4812 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4813 
    args = toggleDOAFlag_args()
4814 
    args.read(iprot)
4815 
    iprot.readMessageEnd()
4816 
    result = toggleDOAFlag_result()
4817 
    try:
4818 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4819 
    except TransactionServiceException, ex:
4820 
      result.ex = ex
4821 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4822 
    result.write(oprot)
4823 
    oprot.writeMessageEnd()
4824 
    oprot.trans.flush()
1886 ankur.sing 4825 
 
4454 rajveer 4826 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4827 
    args = markOrderDoaRequestReceived_args()
4828 
    args.read(iprot)
4829 
    iprot.readMessageEnd()
4830 
    result = markOrderDoaRequestReceived_result()
4831 
    try:
4832 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4833 
    except TransactionServiceException, ex:
4834 
      result.ex = ex
4835 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4836 
    result.write(oprot)
4837 
    oprot.writeMessageEnd()
4838 
    oprot.trans.flush()
4839 
 
4840 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4841 
    args = markOrderDoaRequestAuthorized_args()
4842 
    args.read(iprot)
4843 
    iprot.readMessageEnd()
4844 
    result = markOrderDoaRequestAuthorized_result()
4845 
    try:
4846 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4847 
    except TransactionServiceException, ex:
4848 
      result.ex = ex
4849 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
4853 
 
4488 rajveer 4854 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4855 
    args = markOrderReturnRequestReceived_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    result = markOrderReturnRequestReceived_result()
4859 
    try:
4860 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4861 
    except TransactionServiceException, ex:
4862 
      result.ex = ex
4863 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4864 
    result.write(oprot)
4865 
    oprot.writeMessageEnd()
4866 
    oprot.trans.flush()
4867 
 
4868 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4869 
    args = markOrderReturnRequestAuthorized_args()
4870 
    args.read(iprot)
4871 
    iprot.readMessageEnd()
4872 
    result = markOrderReturnRequestAuthorized_result()
4873 
    try:
4874 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4875 
    except TransactionServiceException, ex:
4876 
      result.ex = ex
4877 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4878 
    result.write(oprot)
4879 
    oprot.writeMessageEnd()
4880 
    oprot.trans.flush()
4881 
 
2536 chandransh 4882 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4883 
    args = requestPickupNumber_args()
4884 
    args.read(iprot)
4885 
    iprot.readMessageEnd()
4886 
    result = requestPickupNumber_result()
4887 
    try:
4579 rajveer 4888 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4889 
    except TransactionServiceException, ex:
4890 
      result.ex = ex
4891 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4892 
    result.write(oprot)
4893 
    oprot.writeMessageEnd()
4894 
    oprot.trans.flush()
4895 
 
4896 
  def process_authorizePickup(self, seqid, iprot, oprot):
4897 
    args = authorizePickup_args()
4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
4900 
    result = authorizePickup_result()
4901 
    try:
4602 rajveer 4902 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 4903 
    except TransactionServiceException, ex:
4904 
      result.ex = ex
4905 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
2764 chandransh 4910 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4911 
    args = markDoasAsPickedUp_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = markDoasAsPickedUp_result()
4915 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4916 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
4920 
 
2616 chandransh 4921 
  def process_receiveReturn(self, seqid, iprot, oprot):
4922 
    args = receiveReturn_args()
2591 chandransh 4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
2616 chandransh 4925 
    result = receiveReturn_result()
2591 chandransh 4926 
    try:
4479 rajveer 4927 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4928 
    except TransactionServiceException, ex:
4929 
      result.ex = ex
2616 chandransh 4930 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4931 
    result.write(oprot)
4932 
    oprot.writeMessageEnd()
4933 
    oprot.trans.flush()
2536 chandransh 4934 
 
2591 chandransh 4935 
  def process_validateDoa(self, seqid, iprot, oprot):
4936 
    args = validateDoa_args()
4937 
    args.read(iprot)
4938 
    iprot.readMessageEnd()
4939 
    result = validateDoa_result()
4940 
    try:
4941 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4942 
    except TransactionServiceException, ex:
4943 
      result.ex = ex
4944 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
4495 rajveer 4949 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4950 
    args = validateReturnProduct_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = validateReturnProduct_result()
4954 
    try:
4955 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4956 
    except TransactionServiceException, ex:
4957 
      result.ex = ex
4958 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
4962 
 
2616 chandransh 4963 
  def process_reshipOrder(self, seqid, iprot, oprot):
4964 
    args = reshipOrder_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = reshipOrder_result()
4968 
    try:
4969 
      result.success = self._handler.reshipOrder(args.orderId)
4970 
    except TransactionServiceException, ex:
4971 
      result.ex = ex
4972 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4973 
    result.write(oprot)
4974 
    oprot.writeMessageEnd()
4975 
    oprot.trans.flush()
2591 chandransh 4976 
 
2616 chandransh 4977 
  def process_refundOrder(self, seqid, iprot, oprot):
4978 
    args = refundOrder_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = refundOrder_result()
4982 
    try:
3226 chandransh 4983 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4984 
    except TransactionServiceException, ex:
4985 
      result.ex = ex
4986 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
4990 
 
2690 chandransh 4991 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4992 
    args = getReturnOrders_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = getReturnOrders_result()
4996 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4997 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4998 
    result.write(oprot)
4999 
    oprot.writeMessageEnd()
5000 
    oprot.trans.flush()
2616 chandransh 5001 
 
2700 chandransh 5002 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5003 
    args = getReturnOrder_args()
5004 
    args.read(iprot)
5005 
    iprot.readMessageEnd()
5006 
    result = getReturnOrder_result()
5007 
    try:
5008 
      result.success = self._handler.getReturnOrder(args.id)
5009 
    except TransactionServiceException, ex:
5010 
      result.ex = ex
5011 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5012 
    result.write(oprot)
5013 
    oprot.writeMessageEnd()
5014 
    oprot.trans.flush()
5015 
 
2690 chandransh 5016 
  def process_processReturn(self, seqid, iprot, oprot):
5017 
    args = processReturn_args()
5018 
    args.read(iprot)
5019 
    iprot.readMessageEnd()
5020 
    result = processReturn_result()
5021 
    try:
5022 
      self._handler.processReturn(args.returnOrderId)
5023 
    except TransactionServiceException, ex:
5024 
      result.ex = ex
5025 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5026 
    result.write(oprot)
5027 
    oprot.writeMessageEnd()
5028 
    oprot.trans.flush()
5029 
 
2819 chandransh 5030 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5031 
    args = createPurchaseOrder_args()
5032 
    args.read(iprot)
5033 
    iprot.readMessageEnd()
5034 
    result = createPurchaseOrder_result()
5035 
    try:
5036 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5037 
    except TransactionServiceException, ex:
5038 
      result.ex = ex
5039 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5040 
    result.write(oprot)
5041 
    oprot.writeMessageEnd()
5042 
    oprot.trans.flush()
2690 chandransh 5043 
 
3451 chandransh 5044 
  def process_updateWeight(self, seqid, iprot, oprot):
5045 
    args = updateWeight_args()
5046 
    args.read(iprot)
5047 
    iprot.readMessageEnd()
5048 
    result = updateWeight_result()
5049 
    try:
5050 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5051 
    except TransactionServiceException, ex:
5052 
      result.ex = ex
5053 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5054 
    result.write(oprot)
5055 
    oprot.writeMessageEnd()
5056 
    oprot.trans.flush()
2819 chandransh 5057 
 
3469 chandransh 5058 
  def process_changeItem(self, seqid, iprot, oprot):
5059 
    args = changeItem_args()
5060 
    args.read(iprot)
5061 
    iprot.readMessageEnd()
5062 
    result = changeItem_result()
5063 
    try:
5064 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5065 
    except TransactionServiceException, ex:
5066 
      result.ex = ex
5067 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5068 
    result.write(oprot)
5069 
    oprot.writeMessageEnd()
5070 
    oprot.trans.flush()
3451 chandransh 5071 
 
3469 chandransh 5072 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5073 
    args = shiftToWarehouse_args()
5074 
    args.read(iprot)
5075 
    iprot.readMessageEnd()
5076 
    result = shiftToWarehouse_result()
5077 
    try:
5078 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5079 
    except TransactionServiceException, ex:
5080 
      result.ex = ex
5081 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5082 
    result.write(oprot)
5083 
    oprot.writeMessageEnd()
5084 
    oprot.trans.flush()
5085 
 
3553 chandransh 5086 
  def process_addDelayReason(self, seqid, iprot, oprot):
5087 
    args = addDelayReason_args()
5088 
    args.read(iprot)
5089 
    iprot.readMessageEnd()
5090 
    result = addDelayReason_result()
5091 
    try:
4647 rajveer 5092 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5093 
    except TransactionServiceException, ex:
5094 
      result.ex = ex
5095 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5096 
    result.write(oprot)
5097 
    oprot.writeMessageEnd()
5098 
    oprot.trans.flush()
3469 chandransh 5099 
 
3956 chandransh 5100 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5101 
    args = reconcileCodCollection_args()
5102 
    args.read(iprot)
5103 
    iprot.readMessageEnd()
5104 
    result = reconcileCodCollection_result()
5105 
    try:
5106 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5107 
    except TransactionServiceException, ex:
5108 
      result.ex = ex
5109 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5110 
    result.write(oprot)
5111 
    oprot.writeMessageEnd()
5112 
    oprot.trans.flush()
3553 chandransh 5113 
 
4008 mandeep.dh 5114 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5115 
    args = getTransactionsRequiringExtraProcessing_args()
5116 
    args.read(iprot)
5117 
    iprot.readMessageEnd()
5118 
    result = getTransactionsRequiringExtraProcessing_result()
5119 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5120 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5121 
    result.write(oprot)
5122 
    oprot.writeMessageEnd()
5123 
    oprot.trans.flush()
3956 chandransh 5124 
 
4008 mandeep.dh 5125 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5126 
    args = markTransactionAsProcessed_args()
5127 
    args.read(iprot)
5128 
    iprot.readMessageEnd()
5129 
    result = markTransactionAsProcessed_result()
5130 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5131 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5132 
    result.write(oprot)
5133 
    oprot.writeMessageEnd()
5134 
    oprot.trans.flush()
5135 
 
4018 chandransh 5136 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5137 
    args = getItemWiseRiskyOrdersCount_args()
5138 
    args.read(iprot)
5139 
    iprot.readMessageEnd()
5140 
    result = getItemWiseRiskyOrdersCount_result()
5141 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5142 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5143 
    result.write(oprot)
5144 
    oprot.writeMessageEnd()
5145 
    oprot.trans.flush()
4008 mandeep.dh 5146 
 
4295 varun.gupt 5147 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5148 
    args = getOrdersForItemIds_args()
5149 
    args.read(iprot)
5150 
    iprot.readMessageEnd()
5151 
    result = getOrdersForItemIds_result()
5152 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5153 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5154 
    result.write(oprot)
5155 
    oprot.writeMessageEnd()
5156 
    oprot.trans.flush()
5157 
 
4247 rajveer 5158 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5159 
    args = markOrderCancellationRequestReceived_args()
5160 
    args.read(iprot)
5161 
    iprot.readMessageEnd()
5162 
    result = markOrderCancellationRequestReceived_result()
5163 
    try:
5164 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5165 
    except TransactionServiceException, ex:
5166 
      result.ex = ex
5167 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5168 
    result.write(oprot)
5169 
    oprot.writeMessageEnd()
5170 
    oprot.trans.flush()
4018 chandransh 5171 
 
4247 rajveer 5172 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5173 
    args = markOrderCancellationRequestConfirmed_args()
5174 
    args.read(iprot)
5175 
    iprot.readMessageEnd()
5176 
    result = markOrderCancellationRequestConfirmed_result()
5177 
    try:
5178 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5179 
    except TransactionServiceException, ex:
5180 
      result.ex = ex
5181 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
5186 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5187 
    args = markOrderCancellationRequestDenied_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = markOrderCancellationRequestDenied_result()
5191 
    try:
5192 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5193 
    except TransactionServiceException, ex:
5194 
      result.ex = ex
5195 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5196 
    result.write(oprot)
5197 
    oprot.writeMessageEnd()
5198 
    oprot.trans.flush()
5199 
 
4258 rajveer 5200 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5201 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5202 
    args.read(iprot)
5203 
    iprot.readMessageEnd()
4258 rajveer 5204 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5205 
    try:
4258 rajveer 5206 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5207 
    except TransactionServiceException, ex:
5208 
      result.ex = ex
4258 rajveer 5209 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
4259 anupam.sin 5214 
  def process_refundTransaction(self, seqid, iprot, oprot):
5215 
    args = refundTransaction_args()
5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
5218 
    result = refundTransaction_result()
5219 
    try:
5220 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5221 
    except TransactionServiceException, ex:
5222 
      result.ex = ex
5223 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
4247 rajveer 5227 
 
4324 mandeep.dh 5228 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5229 
    args = updateShipmentAddress_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = updateShipmentAddress_result()
5233 
    try:
5234 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5235 
    except TransactionServiceException, ex:
5236 
      result.ex = ex
5237 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
5241 
 
4285 rajveer 5242 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5243 
    args = acceptOrdersForItemId_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = acceptOrdersForItemId_result()
5247 
    try:
5248 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5249 
    except TransactionServiceException, ex:
5250 
      result.ex = ex
5251 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
4259 anupam.sin 5255 
 
4303 rajveer 5256 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5257 
    args = markOrdersAsPORaised_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = markOrdersAsPORaised_result()
5261 
    try:
4369 rajveer 5262 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5263 
    except TransactionServiceException, ex:
5264 
      result.ex = ex
5265 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
4285 rajveer 5269 
 
4303 rajveer 5270 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5271 
    args = markOrdersAsReversalInitiated_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = markOrdersAsReversalInitiated_result()
5275 
    try:
4369 rajveer 5276 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5277 
    except TransactionServiceException, ex:
5278 
      result.ex = ex
5279 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5280 
    result.write(oprot)
5281 
    oprot.writeMessageEnd()
5282 
    oprot.trans.flush()
5283 
 
5284 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5285 
    args = markOrdersAsNotAvailabke_args()
5286 
    args.read(iprot)
5287 
    iprot.readMessageEnd()
5288 
    result = markOrdersAsNotAvailabke_result()
5289 
    try:
4369 rajveer 5290 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5291 
    except TransactionServiceException, ex:
5292 
      result.ex = ex
5293 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5294 
    result.write(oprot)
5295 
    oprot.writeMessageEnd()
5296 
    oprot.trans.flush()
5297 
 
4369 rajveer 5298 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5299 
    args = markOrdersAsTimeout_args()
5300 
    args.read(iprot)
5301 
    iprot.readMessageEnd()
5302 
    result = markOrdersAsTimeout_result()
5303 
    try:
5304 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5305 
    except TransactionServiceException, ex:
5306 
      result.ex = ex
5307 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5308 
    result.write(oprot)
5309 
    oprot.writeMessageEnd()
5310 
    oprot.trans.flush()
4303 rajveer 5311 
 
4386 anupam.sin 5312 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5313 
    args = getOrderForAwb_args()
5314 
    args.read(iprot)
5315 
    iprot.readMessageEnd()
5316 
    result = getOrderForAwb_result()
5317 
    try:
5318 
      result.success = self._handler.getOrderForAwb(args.awb)
5319 
    except TransactionServiceException, ex:
5320 
      result.ex = ex
5321 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
4369 rajveer 5325 
 
4506 phani.kuma 5326 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5327 
    args = getOrdersForProviderForStatus_args()
5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
5330 
    result = getOrdersForProviderForStatus_result()
5331 
    try:
5332 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5333 
    except TransactionServiceException, ex:
5334 
      result.ex = ex
5335 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
4386 anupam.sin 5339 
 
4600 varun.gupt 5340 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5341 
    args = getBilledOrdersForVendor_args()
5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
5344 
    result = getBilledOrdersForVendor_result()
5345 
    try:
5346 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5347 
    except TransactionServiceException, ex:
5348 
      result.ex = ex
5349 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5350 
    result.write(oprot)
5351 
    oprot.writeMessageEnd()
5352 
    oprot.trans.flush()
4506 phani.kuma 5353 
 
4607 rajveer 5354 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5355 
    args = getSlippedSippingDateOrders_args()
5356 
    args.read(iprot)
5357 
    iprot.readMessageEnd()
5358 
    result = getSlippedSippingDateOrders_result()
5359 
    try:
5360 
      result.success = self._handler.getSlippedSippingDateOrders()
5361 
    except TransactionServiceException, ex:
5362 
      result.ex = ex
5363 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5364 
    result.write(oprot)
5365 
    oprot.writeMessageEnd()
5366 
    oprot.trans.flush()
5367 
 
4600 varun.gupt 5368 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5369 
    args = saveBluedartSettlements_args()
5370 
    args.read(iprot)
5371 
    iprot.readMessageEnd()
5372 
    result = saveBluedartSettlements_result()
5373 
    try:
5374 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5375 
    except TransactionServiceException, ex:
5376 
      result.ex = ex
5377 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5378 
    result.write(oprot)
5379 
    oprot.writeMessageEnd()
5380 
    oprot.trans.flush()
5381 
 
5382 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5383 
    args = savePaymentSettlements_args()
5384 
    args.read(iprot)
5385 
    iprot.readMessageEnd()
5386 
    result = savePaymentSettlements_result()
5387 
    try:
5388 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5389 
    except TransactionServiceException, ex:
5390 
      result.ex = ex
5391 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5392 
    result.write(oprot)
5393 
    oprot.writeMessageEnd()
5394 
    oprot.trans.flush()
5395 
 
5396 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5397 
    args = saveEBSSettlementSummary_args()
5398 
    args.read(iprot)
5399 
    iprot.readMessageEnd()
5400 
    result = saveEBSSettlementSummary_result()
5401 
    try:
5402 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5403 
    except TransactionServiceException, ex:
5404 
      result.ex = ex
5405 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5406 
    result.write(oprot)
5407 
    oprot.writeMessageEnd()
5408 
    oprot.trans.flush()
5409 
 
5410 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5411 
    args = getSettlementForPaymentId_args()
5412 
    args.read(iprot)
5413 
    iprot.readMessageEnd()
5414 
    result = getSettlementForPaymentId_result()
5415 
    try:
5416 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5417 
    except TransactionServiceException, ex:
5418 
      result.ex = ex
5419 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5420 
    result.write(oprot)
5421 
    oprot.writeMessageEnd()
5422 
    oprot.trans.flush()
5423 
 
5424 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5425 
    args = getEBSSettlementSummaries_args()
5426 
    args.read(iprot)
5427 
    iprot.readMessageEnd()
5428 
    result = getEBSSettlementSummaries_result()
5429 
    try:
5430 
      result.success = self._handler.getEBSSettlementSummaries()
5431 
    except TransactionServiceException, ex:
5432 
      result.ex = ex
5433 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5434 
    result.write(oprot)
5435 
    oprot.writeMessageEnd()
5436 
    oprot.trans.flush()
5437 
 
5438 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5439 
    args = markEBSSettlementUploaded_args()
5440 
    args.read(iprot)
5441 
    iprot.readMessageEnd()
5442 
    result = markEBSSettlementUploaded_result()
5443 
    try:
5444 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5445 
    except TransactionServiceException, ex:
5446 
      result.ex = ex
5447 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5448 
    result.write(oprot)
5449 
    oprot.writeMessageEnd()
5450 
    oprot.trans.flush()
5451 
 
5452 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5453 
    args = getEBSSettlementDate_args()
5454 
    args.read(iprot)
5455 
    iprot.readMessageEnd()
5456 
    result = getEBSSettlementDate_result()
5457 
    try:
5458 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5459 
    except TransactionServiceException, ex:
5460 
      result.ex = ex
5461 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5462 
    result.write(oprot)
5463 
    oprot.writeMessageEnd()
5464 
    oprot.trans.flush()
5465 
 
5466 
 
94 ashish 5467 
# HELPER FUNCTIONS AND STRUCTURES
5468 
 
5469 
class createTransaction_args:
5470 
  """
5471 
  Attributes:
5472 
   - transaction
5473 
  """
5474 
 
5475 
  thrift_spec = (
5476 
    None, # 0
5477 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5478 
  )
5479 
 
5480 
  def __init__(self, transaction=None,):
5481 
    self.transaction = transaction
5482 
 
5483 
  def read(self, iprot):
5484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5486 
      return
5487 
    iprot.readStructBegin()
5488 
    while True:
5489 
      (fname, ftype, fid) = iprot.readFieldBegin()
5490 
      if ftype == TType.STOP:
5491 
        break
5492 
      if fid == 1:
5493 
        if ftype == TType.STRUCT:
5494 
          self.transaction = Transaction()
5495 
          self.transaction.read(iprot)
5496 
        else:
5497 
          iprot.skip(ftype)
5498 
      else:
5499 
        iprot.skip(ftype)
5500 
      iprot.readFieldEnd()
5501 
    iprot.readStructEnd()
5502 
 
5503 
  def write(self, oprot):
5504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5506 
      return
5507 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5508 
    if self.transaction is not None:
94 ashish 5509 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5510 
      self.transaction.write(oprot)
5511 
      oprot.writeFieldEnd()
5512 
    oprot.writeFieldStop()
5513 
    oprot.writeStructEnd()
5514 
 
3431 rajveer 5515 
  def validate(self):
5516 
    return
5517 
 
5518 
 
94 ashish 5519 
  def __repr__(self):
5520 
    L = ['%s=%r' % (key, value)
5521 
      for key, value in self.__dict__.iteritems()]
5522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5523 
 
5524 
  def __eq__(self, other):
5525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5526 
 
5527 
  def __ne__(self, other):
5528 
    return not (self == other)
5529 
 
5530 
class createTransaction_result:
5531 
  """
5532 
  Attributes:
132 ashish 5533 
   - success
94 ashish 5534 
   - ex
5535 
  """
5536 
 
5537 
  thrift_spec = (
132 ashish 5538 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5540 
  )
5541 
 
132 ashish 5542 
  def __init__(self, success=None, ex=None,):
5543 
    self.success = success
94 ashish 5544 
    self.ex = ex
5545 
 
5546 
  def read(self, iprot):
5547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5549 
      return
5550 
    iprot.readStructBegin()
5551 
    while True:
5552 
      (fname, ftype, fid) = iprot.readFieldBegin()
5553 
      if ftype == TType.STOP:
5554 
        break
132 ashish 5555 
      if fid == 0:
5556 
        if ftype == TType.I64:
5557 
          self.success = iprot.readI64();
5558 
        else:
5559 
          iprot.skip(ftype)
5560 
      elif fid == 1:
94 ashish 5561 
        if ftype == TType.STRUCT:
5562 
          self.ex = TransactionServiceException()
5563 
          self.ex.read(iprot)
5564 
        else:
5565 
          iprot.skip(ftype)
5566 
      else:
5567 
        iprot.skip(ftype)
5568 
      iprot.readFieldEnd()
5569 
    iprot.readStructEnd()
5570 
 
5571 
  def write(self, oprot):
5572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5574 
      return
5575 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5576 
    if self.success is not None:
132 ashish 5577 
      oprot.writeFieldBegin('success', TType.I64, 0)
5578 
      oprot.writeI64(self.success)
5579 
      oprot.writeFieldEnd()
3431 rajveer 5580 
    if self.ex is not None:
94 ashish 5581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5582 
      self.ex.write(oprot)
5583 
      oprot.writeFieldEnd()
5584 
    oprot.writeFieldStop()
5585 
    oprot.writeStructEnd()
5586 
 
3431 rajveer 5587 
  def validate(self):
5588 
    return
5589 
 
5590 
 
94 ashish 5591 
  def __repr__(self):
5592 
    L = ['%s=%r' % (key, value)
5593 
      for key, value in self.__dict__.iteritems()]
5594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5595 
 
5596 
  def __eq__(self, other):
5597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5598 
 
5599 
  def __ne__(self, other):
5600 
    return not (self == other)
5601 
 
5602 
class getTransaction_args:
5603 
  """
5604 
  Attributes:
5605 
   - id
5606 
  """
5607 
 
5608 
  thrift_spec = (
5609 
    None, # 0
5610 
    (1, TType.I64, 'id', None, None, ), # 1
5611 
  )
5612 
 
5613 
  def __init__(self, id=None,):
5614 
    self.id = id
5615 
 
5616 
  def read(self, iprot):
5617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5619 
      return
5620 
    iprot.readStructBegin()
5621 
    while True:
5622 
      (fname, ftype, fid) = iprot.readFieldBegin()
5623 
      if ftype == TType.STOP:
5624 
        break
5625 
      if fid == 1:
5626 
        if ftype == TType.I64:
5627 
          self.id = iprot.readI64();
5628 
        else:
5629 
          iprot.skip(ftype)
5630 
      else:
5631 
        iprot.skip(ftype)
5632 
      iprot.readFieldEnd()
5633 
    iprot.readStructEnd()
5634 
 
5635 
  def write(self, oprot):
5636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5638 
      return
5639 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5640 
    if self.id is not None:
94 ashish 5641 
      oprot.writeFieldBegin('id', TType.I64, 1)
5642 
      oprot.writeI64(self.id)
5643 
      oprot.writeFieldEnd()
5644 
    oprot.writeFieldStop()
5645 
    oprot.writeStructEnd()
5646 
 
3431 rajveer 5647 
  def validate(self):
5648 
    return
5649 
 
5650 
 
94 ashish 5651 
  def __repr__(self):
5652 
    L = ['%s=%r' % (key, value)
5653 
      for key, value in self.__dict__.iteritems()]
5654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5655 
 
5656 
  def __eq__(self, other):
5657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5658 
 
5659 
  def __ne__(self, other):
5660 
    return not (self == other)
5661 
 
5662 
class getTransaction_result:
5663 
  """
5664 
  Attributes:
5665 
   - success
5666 
   - ex
5667 
  """
5668 
 
5669 
  thrift_spec = (
5670 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5672 
  )
5673 
 
5674 
  def __init__(self, success=None, ex=None,):
5675 
    self.success = success
5676 
    self.ex = ex
5677 
 
5678 
  def read(self, iprot):
5679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5681 
      return
5682 
    iprot.readStructBegin()
5683 
    while True:
5684 
      (fname, ftype, fid) = iprot.readFieldBegin()
5685 
      if ftype == TType.STOP:
5686 
        break
5687 
      if fid == 0:
5688 
        if ftype == TType.STRUCT:
5689 
          self.success = Transaction()
5690 
          self.success.read(iprot)
5691 
        else:
5692 
          iprot.skip(ftype)
5693 
      elif fid == 1:
5694 
        if ftype == TType.STRUCT:
5695 
          self.ex = TransactionServiceException()
5696 
          self.ex.read(iprot)
5697 
        else:
5698 
          iprot.skip(ftype)
5699 
      else:
5700 
        iprot.skip(ftype)
5701 
      iprot.readFieldEnd()
5702 
    iprot.readStructEnd()
5703 
 
5704 
  def write(self, oprot):
5705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5707 
      return
5708 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5709 
    if self.success is not None:
94 ashish 5710 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5711 
      self.success.write(oprot)
5712 
      oprot.writeFieldEnd()
3431 rajveer 5713 
    if self.ex is not None:
94 ashish 5714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5715 
      self.ex.write(oprot)
5716 
      oprot.writeFieldEnd()
5717 
    oprot.writeFieldStop()
5718 
    oprot.writeStructEnd()
5719 
 
3431 rajveer 5720 
  def validate(self):
5721 
    return
5722 
 
5723 
 
94 ashish 5724 
  def __repr__(self):
5725 
    L = ['%s=%r' % (key, value)
5726 
      for key, value in self.__dict__.iteritems()]
5727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5728 
 
5729 
  def __eq__(self, other):
5730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5731 
 
5732 
  def __ne__(self, other):
5733 
    return not (self == other)
5734 
 
5735 
class getTransactionsForCustomer_args:
5736 
  """
5737 
  Attributes:
5738 
   - customerId
5739 
   - from_date
5740 
   - to_date
5741 
   - status
5742 
  """
5743 
 
5744 
  thrift_spec = (
5745 
    None, # 0
5746 
    (1, TType.I64, 'customerId', None, None, ), # 1
5747 
    (2, TType.I64, 'from_date', None, None, ), # 2
5748 
    (3, TType.I64, 'to_date', None, None, ), # 3
5749 
    (4, TType.I32, 'status', None, None, ), # 4
5750 
  )
5751 
 
5752 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5753 
    self.customerId = customerId
5754 
    self.from_date = from_date
5755 
    self.to_date = to_date
5756 
    self.status = status
5757 
 
5758 
  def read(self, iprot):
5759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5761 
      return
5762 
    iprot.readStructBegin()
5763 
    while True:
5764 
      (fname, ftype, fid) = iprot.readFieldBegin()
5765 
      if ftype == TType.STOP:
5766 
        break
5767 
      if fid == 1:
5768 
        if ftype == TType.I64:
5769 
          self.customerId = iprot.readI64();
5770 
        else:
5771 
          iprot.skip(ftype)
5772 
      elif fid == 2:
5773 
        if ftype == TType.I64:
5774 
          self.from_date = iprot.readI64();
5775 
        else:
5776 
          iprot.skip(ftype)
5777 
      elif fid == 3:
5778 
        if ftype == TType.I64:
5779 
          self.to_date = iprot.readI64();
5780 
        else:
5781 
          iprot.skip(ftype)
5782 
      elif fid == 4:
5783 
        if ftype == TType.I32:
5784 
          self.status = iprot.readI32();
5785 
        else:
5786 
          iprot.skip(ftype)
5787 
      else:
5788 
        iprot.skip(ftype)
5789 
      iprot.readFieldEnd()
5790 
    iprot.readStructEnd()
5791 
 
5792 
  def write(self, oprot):
5793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5795 
      return
5796 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5797 
    if self.customerId is not None:
94 ashish 5798 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5799 
      oprot.writeI64(self.customerId)
5800 
      oprot.writeFieldEnd()
3431 rajveer 5801 
    if self.from_date is not None:
94 ashish 5802 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5803 
      oprot.writeI64(self.from_date)
5804 
      oprot.writeFieldEnd()
3431 rajveer 5805 
    if self.to_date is not None:
94 ashish 5806 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5807 
      oprot.writeI64(self.to_date)
5808 
      oprot.writeFieldEnd()
3431 rajveer 5809 
    if self.status is not None:
94 ashish 5810 
      oprot.writeFieldBegin('status', TType.I32, 4)
5811 
      oprot.writeI32(self.status)
5812 
      oprot.writeFieldEnd()
5813 
    oprot.writeFieldStop()
5814 
    oprot.writeStructEnd()
5815 
 
3431 rajveer 5816 
  def validate(self):
5817 
    return
5818 
 
5819 
 
94 ashish 5820 
  def __repr__(self):
5821 
    L = ['%s=%r' % (key, value)
5822 
      for key, value in self.__dict__.iteritems()]
5823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5824 
 
5825 
  def __eq__(self, other):
5826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5827 
 
5828 
  def __ne__(self, other):
5829 
    return not (self == other)
5830 
 
5831 
class getTransactionsForCustomer_result:
5832 
  """
5833 
  Attributes:
5834 
   - success
5835 
   - ex
5836 
  """
5837 
 
5838 
  thrift_spec = (
5839 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5841 
  )
5842 
 
5843 
  def __init__(self, success=None, ex=None,):
5844 
    self.success = success
5845 
    self.ex = ex
5846 
 
5847 
  def read(self, iprot):
5848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5850 
      return
5851 
    iprot.readStructBegin()
5852 
    while True:
5853 
      (fname, ftype, fid) = iprot.readFieldBegin()
5854 
      if ftype == TType.STOP:
5855 
        break
5856 
      if fid == 0:
5857 
        if ftype == TType.LIST:
5858 
          self.success = []
685 chandransh 5859 
          (_etype17, _size14) = iprot.readListBegin()
5860 
          for _i18 in xrange(_size14):
5861 
            _elem19 = Transaction()
5862 
            _elem19.read(iprot)
5863 
            self.success.append(_elem19)
94 ashish 5864 
          iprot.readListEnd()
5865 
        else:
5866 
          iprot.skip(ftype)
5867 
      elif fid == 1:
5868 
        if ftype == TType.STRUCT:
5869 
          self.ex = TransactionServiceException()
5870 
          self.ex.read(iprot)
5871 
        else:
5872 
          iprot.skip(ftype)
5873 
      else:
5874 
        iprot.skip(ftype)
5875 
      iprot.readFieldEnd()
5876 
    iprot.readStructEnd()
5877 
 
5878 
  def write(self, oprot):
5879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5881 
      return
5882 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5883 
    if self.success is not None:
94 ashish 5884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5886 
      for iter20 in self.success:
5887 
        iter20.write(oprot)
94 ashish 5888 
      oprot.writeListEnd()
5889 
      oprot.writeFieldEnd()
3431 rajveer 5890 
    if self.ex is not None:
94 ashish 5891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5892 
      self.ex.write(oprot)
5893 
      oprot.writeFieldEnd()
5894 
    oprot.writeFieldStop()
5895 
    oprot.writeStructEnd()
5896 
 
3431 rajveer 5897 
  def validate(self):
5898 
    return
5899 
 
5900 
 
94 ashish 5901 
  def __repr__(self):
5902 
    L = ['%s=%r' % (key, value)
5903 
      for key, value in self.__dict__.iteritems()]
5904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5905 
 
5906 
  def __eq__(self, other):
5907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5908 
 
5909 
  def __ne__(self, other):
5910 
    return not (self == other)
5911 
 
132 ashish 5912 
class getTransactionsForShoppingCartId_args:
5913 
  """
5914 
  Attributes:
5915 
   - shoppingCartId
5916 
  """
5917 
 
5918 
  thrift_spec = (
5919 
    None, # 0
5920 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5921 
  )
5922 
 
5923 
  def __init__(self, shoppingCartId=None,):
5924 
    self.shoppingCartId = shoppingCartId
5925 
 
5926 
  def read(self, iprot):
5927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5929 
      return
5930 
    iprot.readStructBegin()
5931 
    while True:
5932 
      (fname, ftype, fid) = iprot.readFieldBegin()
5933 
      if ftype == TType.STOP:
5934 
        break
5935 
      if fid == 1:
5936 
        if ftype == TType.I64:
5937 
          self.shoppingCartId = iprot.readI64();
5938 
        else:
5939 
          iprot.skip(ftype)
5940 
      else:
5941 
        iprot.skip(ftype)
5942 
      iprot.readFieldEnd()
5943 
    iprot.readStructEnd()
5944 
 
5945 
  def write(self, oprot):
5946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5948 
      return
5949 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5950 
    if self.shoppingCartId is not None:
132 ashish 5951 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5952 
      oprot.writeI64(self.shoppingCartId)
5953 
      oprot.writeFieldEnd()
5954 
    oprot.writeFieldStop()
5955 
    oprot.writeStructEnd()
5956 
 
3431 rajveer 5957 
  def validate(self):
5958 
    return
5959 
 
5960 
 
132 ashish 5961 
  def __repr__(self):
5962 
    L = ['%s=%r' % (key, value)
5963 
      for key, value in self.__dict__.iteritems()]
5964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5965 
 
5966 
  def __eq__(self, other):
5967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5968 
 
5969 
  def __ne__(self, other):
5970 
    return not (self == other)
5971 
 
5972 
class getTransactionsForShoppingCartId_result:
5973 
  """
5974 
  Attributes:
5975 
   - success
5976 
   - ex
5977 
  """
5978 
 
5979 
  thrift_spec = (
5980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5982 
  )
5983 
 
5984 
  def __init__(self, success=None, ex=None,):
5985 
    self.success = success
5986 
    self.ex = ex
5987 
 
5988 
  def read(self, iprot):
5989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5991 
      return
5992 
    iprot.readStructBegin()
5993 
    while True:
5994 
      (fname, ftype, fid) = iprot.readFieldBegin()
5995 
      if ftype == TType.STOP:
5996 
        break
5997 
      if fid == 0:
5998 
        if ftype == TType.LIST:
5999 
          self.success = []
685 chandransh 6000 
          (_etype24, _size21) = iprot.readListBegin()
6001 
          for _i25 in xrange(_size21):
6002 
            _elem26 = Transaction()
6003 
            _elem26.read(iprot)
6004 
            self.success.append(_elem26)
132 ashish 6005 
          iprot.readListEnd()
6006 
        else:
6007 
          iprot.skip(ftype)
6008 
      elif fid == 1:
6009 
        if ftype == TType.STRUCT:
6010 
          self.ex = TransactionServiceException()
6011 
          self.ex.read(iprot)
6012 
        else:
6013 
          iprot.skip(ftype)
6014 
      else:
6015 
        iprot.skip(ftype)
6016 
      iprot.readFieldEnd()
6017 
    iprot.readStructEnd()
6018 
 
6019 
  def write(self, oprot):
6020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6022 
      return
6023 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6024 
    if self.success is not None:
132 ashish 6025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6027 
      for iter27 in self.success:
6028 
        iter27.write(oprot)
132 ashish 6029 
      oprot.writeListEnd()
6030 
      oprot.writeFieldEnd()
3431 rajveer 6031 
    if self.ex is not None:
132 ashish 6032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6033 
      self.ex.write(oprot)
6034 
      oprot.writeFieldEnd()
6035 
    oprot.writeFieldStop()
6036 
    oprot.writeStructEnd()
6037 
 
3431 rajveer 6038 
  def validate(self):
6039 
    return
6040 
 
6041 
 
132 ashish 6042 
  def __repr__(self):
6043 
    L = ['%s=%r' % (key, value)
6044 
      for key, value in self.__dict__.iteritems()]
6045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6046 
 
6047 
  def __eq__(self, other):
6048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6049 
 
6050 
  def __ne__(self, other):
6051 
    return not (self == other)
6052 
 
94 ashish 6053 
class getTransactionStatus_args:
6054 
  """
6055 
  Attributes:
6056 
   - transactionId
6057 
  """
6058 
 
6059 
  thrift_spec = (
6060 
    None, # 0
6061 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6062 
  )
6063 
 
6064 
  def __init__(self, transactionId=None,):
6065 
    self.transactionId = transactionId
6066 
 
6067 
  def read(self, iprot):
6068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6070 
      return
6071 
    iprot.readStructBegin()
6072 
    while True:
6073 
      (fname, ftype, fid) = iprot.readFieldBegin()
6074 
      if ftype == TType.STOP:
6075 
        break
6076 
      if fid == 1:
6077 
        if ftype == TType.I64:
6078 
          self.transactionId = iprot.readI64();
6079 
        else:
6080 
          iprot.skip(ftype)
6081 
      else:
6082 
        iprot.skip(ftype)
6083 
      iprot.readFieldEnd()
6084 
    iprot.readStructEnd()
6085 
 
6086 
  def write(self, oprot):
6087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6089 
      return
6090 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6091 
    if self.transactionId is not None:
94 ashish 6092 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6093 
      oprot.writeI64(self.transactionId)
6094 
      oprot.writeFieldEnd()
6095 
    oprot.writeFieldStop()
6096 
    oprot.writeStructEnd()
6097 
 
3431 rajveer 6098 
  def validate(self):
6099 
    return
6100 
 
6101 
 
94 ashish 6102 
  def __repr__(self):
6103 
    L = ['%s=%r' % (key, value)
6104 
      for key, value in self.__dict__.iteritems()]
6105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6106 
 
6107 
  def __eq__(self, other):
6108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6109 
 
6110 
  def __ne__(self, other):
6111 
    return not (self == other)
6112 
 
6113 
class getTransactionStatus_result:
6114 
  """
6115 
  Attributes:
6116 
   - success
6117 
   - ex
6118 
  """
6119 
 
6120 
  thrift_spec = (
6121 
    (0, TType.I32, 'success', None, None, ), # 0
6122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6123 
  )
6124 
 
6125 
  def __init__(self, success=None, ex=None,):
6126 
    self.success = success
6127 
    self.ex = ex
6128 
 
6129 
  def read(self, iprot):
6130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6132 
      return
6133 
    iprot.readStructBegin()
6134 
    while True:
6135 
      (fname, ftype, fid) = iprot.readFieldBegin()
6136 
      if ftype == TType.STOP:
6137 
        break
6138 
      if fid == 0:
6139 
        if ftype == TType.I32:
6140 
          self.success = iprot.readI32();
6141 
        else:
6142 
          iprot.skip(ftype)
6143 
      elif fid == 1:
6144 
        if ftype == TType.STRUCT:
6145 
          self.ex = TransactionServiceException()
6146 
          self.ex.read(iprot)
6147 
        else:
6148 
          iprot.skip(ftype)
6149 
      else:
6150 
        iprot.skip(ftype)
6151 
      iprot.readFieldEnd()
6152 
    iprot.readStructEnd()
6153 
 
6154 
  def write(self, oprot):
6155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6157 
      return
6158 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6159 
    if self.success is not None:
94 ashish 6160 
      oprot.writeFieldBegin('success', TType.I32, 0)
6161 
      oprot.writeI32(self.success)
6162 
      oprot.writeFieldEnd()
3431 rajveer 6163 
    if self.ex is not None:
94 ashish 6164 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6165 
      self.ex.write(oprot)
6166 
      oprot.writeFieldEnd()
6167 
    oprot.writeFieldStop()
6168 
    oprot.writeStructEnd()
6169 
 
3431 rajveer 6170 
  def validate(self):
6171 
    return
6172 
 
6173 
 
94 ashish 6174 
  def __repr__(self):
6175 
    L = ['%s=%r' % (key, value)
6176 
      for key, value in self.__dict__.iteritems()]
6177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6178 
 
6179 
  def __eq__(self, other):
6180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6181 
 
6182 
  def __ne__(self, other):
6183 
    return not (self == other)
6184 
 
6185 
class changeTransactionStatus_args:
6186 
  """
6187 
  Attributes:
6188 
   - transactionId
6189 
   - status
6190 
   - description
6191 
  """
6192 
 
6193 
  thrift_spec = (
6194 
    None, # 0
6195 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6196 
    (2, TType.I32, 'status', None, None, ), # 2
6197 
    (3, TType.STRING, 'description', None, None, ), # 3
6198 
  )
6199 
 
6200 
  def __init__(self, transactionId=None, status=None, description=None,):
6201 
    self.transactionId = transactionId
6202 
    self.status = status
6203 
    self.description = description
6204 
 
6205 
  def read(self, iprot):
6206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6208 
      return
6209 
    iprot.readStructBegin()
6210 
    while True:
6211 
      (fname, ftype, fid) = iprot.readFieldBegin()
6212 
      if ftype == TType.STOP:
6213 
        break
6214 
      if fid == 1:
6215 
        if ftype == TType.I64:
6216 
          self.transactionId = iprot.readI64();
6217 
        else:
6218 
          iprot.skip(ftype)
6219 
      elif fid == 2:
6220 
        if ftype == TType.I32:
6221 
          self.status = iprot.readI32();
6222 
        else:
6223 
          iprot.skip(ftype)
6224 
      elif fid == 3:
6225 
        if ftype == TType.STRING:
6226 
          self.description = iprot.readString();
6227 
        else:
6228 
          iprot.skip(ftype)
6229 
      else:
6230 
        iprot.skip(ftype)
6231 
      iprot.readFieldEnd()
6232 
    iprot.readStructEnd()
6233 
 
6234 
  def write(self, oprot):
6235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6237 
      return
6238 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6239 
    if self.transactionId is not None:
94 ashish 6240 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6241 
      oprot.writeI64(self.transactionId)
6242 
      oprot.writeFieldEnd()
3431 rajveer 6243 
    if self.status is not None:
94 ashish 6244 
      oprot.writeFieldBegin('status', TType.I32, 2)
6245 
      oprot.writeI32(self.status)
6246 
      oprot.writeFieldEnd()
3431 rajveer 6247 
    if self.description is not None:
94 ashish 6248 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6249 
      oprot.writeString(self.description)
6250 
      oprot.writeFieldEnd()
6251 
    oprot.writeFieldStop()
6252 
    oprot.writeStructEnd()
6253 
 
3431 rajveer 6254 
  def validate(self):
6255 
    return
6256 
 
6257 
 
94 ashish 6258 
  def __repr__(self):
6259 
    L = ['%s=%r' % (key, value)
6260 
      for key, value in self.__dict__.iteritems()]
6261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6262 
 
6263 
  def __eq__(self, other):
6264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6265 
 
6266 
  def __ne__(self, other):
6267 
    return not (self == other)
6268 
 
6269 
class changeTransactionStatus_result:
6270 
  """
6271 
  Attributes:
6272 
   - success
6273 
   - ex
6274 
  """
6275 
 
6276 
  thrift_spec = (
6277 
    (0, TType.BOOL, 'success', None, None, ), # 0
6278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6279 
  )
6280 
 
6281 
  def __init__(self, success=None, ex=None,):
6282 
    self.success = success
6283 
    self.ex = ex
6284 
 
6285 
  def read(self, iprot):
6286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6288 
      return
6289 
    iprot.readStructBegin()
6290 
    while True:
6291 
      (fname, ftype, fid) = iprot.readFieldBegin()
6292 
      if ftype == TType.STOP:
6293 
        break
6294 
      if fid == 0:
6295 
        if ftype == TType.BOOL:
6296 
          self.success = iprot.readBool();
6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      elif fid == 1:
6300 
        if ftype == TType.STRUCT:
6301 
          self.ex = TransactionServiceException()
6302 
          self.ex.read(iprot)
6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      else:
6306 
        iprot.skip(ftype)
6307 
      iprot.readFieldEnd()
6308 
    iprot.readStructEnd()
6309 
 
6310 
  def write(self, oprot):
6311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6313 
      return
6314 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6315 
    if self.success is not None:
94 ashish 6316 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6317 
      oprot.writeBool(self.success)
6318 
      oprot.writeFieldEnd()
3431 rajveer 6319 
    if self.ex is not None:
94 ashish 6320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6321 
      self.ex.write(oprot)
6322 
      oprot.writeFieldEnd()
6323 
    oprot.writeFieldStop()
6324 
    oprot.writeStructEnd()
6325 
 
3431 rajveer 6326 
  def validate(self):
6327 
    return
6328 
 
6329 
 
94 ashish 6330 
  def __repr__(self):
6331 
    L = ['%s=%r' % (key, value)
6332 
      for key, value in self.__dict__.iteritems()]
6333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6334 
 
6335 
  def __eq__(self, other):
6336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6337 
 
6338 
  def __ne__(self, other):
6339 
    return not (self == other)
6340 
 
1398 varun.gupt 6341 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6342 
  """
6343 
  Attributes:
6344 
   - transactionId
6345 
  """
6346 
 
6347 
  thrift_spec = (
6348 
    None, # 0
6349 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6350 
  )
6351 
 
6352 
  def __init__(self, transactionId=None,):
6353 
    self.transactionId = transactionId
6354 
 
6355 
  def read(self, iprot):
6356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6358 
      return
6359 
    iprot.readStructBegin()
6360 
    while True:
6361 
      (fname, ftype, fid) = iprot.readFieldBegin()
6362 
      if ftype == TType.STOP:
6363 
        break
6364 
      if fid == 1:
6365 
        if ftype == TType.I64:
6366 
          self.transactionId = iprot.readI64();
6367 
        else:
6368 
          iprot.skip(ftype)
6369 
      else:
6370 
        iprot.skip(ftype)
6371 
      iprot.readFieldEnd()
6372 
    iprot.readStructEnd()
6373 
 
6374 
  def write(self, oprot):
6375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6377 
      return
1398 varun.gupt 6378 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6379 
    if self.transactionId is not None:
1382 varun.gupt 6380 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6381 
      oprot.writeI64(self.transactionId)
6382 
      oprot.writeFieldEnd()
6383 
    oprot.writeFieldStop()
6384 
    oprot.writeStructEnd()
6385 
 
3431 rajveer 6386 
  def validate(self):
6387 
    return
6388 
 
6389 
 
1382 varun.gupt 6390 
  def __repr__(self):
6391 
    L = ['%s=%r' % (key, value)
6392 
      for key, value in self.__dict__.iteritems()]
6393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6394 
 
6395 
  def __eq__(self, other):
6396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6397 
 
6398 
  def __ne__(self, other):
6399 
    return not (self == other)
6400 
 
1398 varun.gupt 6401 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6402 
  """
6403 
  Attributes:
6404 
   - success
6405 
   - ex
6406 
  """
6407 
 
6408 
  thrift_spec = (
6409 
    (0, TType.BOOL, 'success', None, None, ), # 0
6410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6411 
  )
6412 
 
6413 
  def __init__(self, success=None, ex=None,):
6414 
    self.success = success
6415 
    self.ex = ex
6416 
 
6417 
  def read(self, iprot):
6418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6420 
      return
6421 
    iprot.readStructBegin()
6422 
    while True:
6423 
      (fname, ftype, fid) = iprot.readFieldBegin()
6424 
      if ftype == TType.STOP:
6425 
        break
6426 
      if fid == 0:
6427 
        if ftype == TType.BOOL:
6428 
          self.success = iprot.readBool();
6429 
        else:
6430 
          iprot.skip(ftype)
6431 
      elif fid == 1:
6432 
        if ftype == TType.STRUCT:
6433 
          self.ex = TransactionServiceException()
6434 
          self.ex.read(iprot)
6435 
        else:
6436 
          iprot.skip(ftype)
6437 
      else:
6438 
        iprot.skip(ftype)
6439 
      iprot.readFieldEnd()
6440 
    iprot.readStructEnd()
6441 
 
6442 
  def write(self, oprot):
6443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6445 
      return
1398 varun.gupt 6446 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6447 
    if self.success is not None:
1382 varun.gupt 6448 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6449 
      oprot.writeBool(self.success)
6450 
      oprot.writeFieldEnd()
3431 rajveer 6451 
    if self.ex is not None:
1382 varun.gupt 6452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6453 
      self.ex.write(oprot)
6454 
      oprot.writeFieldEnd()
6455 
    oprot.writeFieldStop()
6456 
    oprot.writeStructEnd()
6457 
 
3431 rajveer 6458 
  def validate(self):
6459 
    return
6460 
 
6461 
 
1382 varun.gupt 6462 
  def __repr__(self):
6463 
    L = ['%s=%r' % (key, value)
6464 
      for key, value in self.__dict__.iteritems()]
6465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6466 
 
6467 
  def __eq__(self, other):
6468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6469 
 
6470 
  def __ne__(self, other):
6471 
    return not (self == other)
6472 
 
483 rajveer 6473 
class getAllOrders_args:
94 ashish 6474 
  """
6475 
  Attributes:
483 rajveer 6476 
   - status
6477 
   - from_date
6478 
   - to_date
6479 
   - warehouse_id
94 ashish 6480 
  """
6481 
 
6482 
  thrift_spec = (
6483 
    None, # 0
483 rajveer 6484 
    (1, TType.I32, 'status', None, None, ), # 1
6485 
    (2, TType.I64, 'from_date', None, None, ), # 2
6486 
    (3, TType.I64, 'to_date', None, None, ), # 3
6487 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6488 
  )
6489 
 
483 rajveer 6490 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6491 
    self.status = status
6492 
    self.from_date = from_date
6493 
    self.to_date = to_date
6494 
    self.warehouse_id = warehouse_id
94 ashish 6495 
 
6496 
  def read(self, iprot):
6497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6499 
      return
6500 
    iprot.readStructBegin()
6501 
    while True:
6502 
      (fname, ftype, fid) = iprot.readFieldBegin()
6503 
      if ftype == TType.STOP:
6504 
        break
6505 
      if fid == 1:
483 rajveer 6506 
        if ftype == TType.I32:
6507 
          self.status = iprot.readI32();
94 ashish 6508 
        else:
6509 
          iprot.skip(ftype)
483 rajveer 6510 
      elif fid == 2:
6511 
        if ftype == TType.I64:
6512 
          self.from_date = iprot.readI64();
94 ashish 6513 
        else:
6514 
          iprot.skip(ftype)
483 rajveer 6515 
      elif fid == 3:
6516 
        if ftype == TType.I64:
6517 
          self.to_date = iprot.readI64();
94 ashish 6518 
        else:
6519 
          iprot.skip(ftype)
483 rajveer 6520 
      elif fid == 4:
94 ashish 6521 
        if ftype == TType.I64:
483 rajveer 6522 
          self.warehouse_id = iprot.readI64();
94 ashish 6523 
        else:
6524 
          iprot.skip(ftype)
6525 
      else:
6526 
        iprot.skip(ftype)
6527 
      iprot.readFieldEnd()
6528 
    iprot.readStructEnd()
6529 
 
6530 
  def write(self, oprot):
6531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6533 
      return
483 rajveer 6534 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6535 
    if self.status is not None:
483 rajveer 6536 
      oprot.writeFieldBegin('status', TType.I32, 1)
6537 
      oprot.writeI32(self.status)
94 ashish 6538 
      oprot.writeFieldEnd()
3431 rajveer 6539 
    if self.from_date is not None:
483 rajveer 6540 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6541 
      oprot.writeI64(self.from_date)
94 ashish 6542 
      oprot.writeFieldEnd()
3431 rajveer 6543 
    if self.to_date is not None:
483 rajveer 6544 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6545 
      oprot.writeI64(self.to_date)
94 ashish 6546 
      oprot.writeFieldEnd()
3431 rajveer 6547 
    if self.warehouse_id is not None:
483 rajveer 6548 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6549 
      oprot.writeI64(self.warehouse_id)
94 ashish 6550 
      oprot.writeFieldEnd()
6551 
    oprot.writeFieldStop()
6552 
    oprot.writeStructEnd()
6553 
 
3431 rajveer 6554 
  def validate(self):
6555 
    return
6556 
 
6557 
 
94 ashish 6558 
  def __repr__(self):
6559 
    L = ['%s=%r' % (key, value)
6560 
      for key, value in self.__dict__.iteritems()]
6561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6562 
 
6563 
  def __eq__(self, other):
6564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6565 
 
6566 
  def __ne__(self, other):
6567 
    return not (self == other)
6568 
 
483 rajveer 6569 
class getAllOrders_result:
94 ashish 6570 
  """
6571 
  Attributes:
6572 
   - success
6573 
   - ex
6574 
  """
6575 
 
6576 
  thrift_spec = (
483 rajveer 6577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6579 
  )
6580 
 
6581 
  def __init__(self, success=None, ex=None,):
6582 
    self.success = success
6583 
    self.ex = ex
6584 
 
6585 
  def read(self, iprot):
6586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6588 
      return
6589 
    iprot.readStructBegin()
6590 
    while True:
6591 
      (fname, ftype, fid) = iprot.readFieldBegin()
6592 
      if ftype == TType.STOP:
6593 
        break
6594 
      if fid == 0:
483 rajveer 6595 
        if ftype == TType.LIST:
6596 
          self.success = []
685 chandransh 6597 
          (_etype31, _size28) = iprot.readListBegin()
6598 
          for _i32 in xrange(_size28):
6599 
            _elem33 = Order()
6600 
            _elem33.read(iprot)
6601 
            self.success.append(_elem33)
483 rajveer 6602 
          iprot.readListEnd()
94 ashish 6603 
        else:
6604 
          iprot.skip(ftype)
6605 
      elif fid == 1:
6606 
        if ftype == TType.STRUCT:
6607 
          self.ex = TransactionServiceException()
6608 
          self.ex.read(iprot)
6609 
        else:
6610 
          iprot.skip(ftype)
6611 
      else:
6612 
        iprot.skip(ftype)
6613 
      iprot.readFieldEnd()
6614 
    iprot.readStructEnd()
6615 
 
6616 
  def write(self, oprot):
6617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6619 
      return
483 rajveer 6620 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6621 
    if self.success is not None:
483 rajveer 6622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6624 
      for iter34 in self.success:
6625 
        iter34.write(oprot)
483 rajveer 6626 
      oprot.writeListEnd()
94 ashish 6627 
      oprot.writeFieldEnd()
3431 rajveer 6628 
    if self.ex is not None:
94 ashish 6629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6630 
      self.ex.write(oprot)
6631 
      oprot.writeFieldEnd()
6632 
    oprot.writeFieldStop()
6633 
    oprot.writeStructEnd()
6634 
 
3431 rajveer 6635 
  def validate(self):
6636 
    return
6637 
 
6638 
 
94 ashish 6639 
  def __repr__(self):
6640 
    L = ['%s=%r' % (key, value)
6641 
      for key, value in self.__dict__.iteritems()]
6642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6643 
 
6644 
  def __eq__(self, other):
6645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6646 
 
6647 
  def __ne__(self, other):
6648 
    return not (self == other)
6649 
 
4133 chandransh 6650 
class getOrdersInBatch_args:
6651 
  """
6652 
  Attributes:
6653 
   - statuses
6654 
   - offset
6655 
   - limit
6656 
   - warehouse_id
6657 
  """
6658 
 
6659 
  thrift_spec = (
6660 
    None, # 0
6661 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6662 
    (2, TType.I64, 'offset', None, None, ), # 2
6663 
    (3, TType.I64, 'limit', None, None, ), # 3
6664 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6665 
  )
6666 
 
6667 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6668 
    self.statuses = statuses
6669 
    self.offset = offset
6670 
    self.limit = limit
6671 
    self.warehouse_id = warehouse_id
6672 
 
6673 
  def read(self, iprot):
6674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6676 
      return
6677 
    iprot.readStructBegin()
6678 
    while True:
6679 
      (fname, ftype, fid) = iprot.readFieldBegin()
6680 
      if ftype == TType.STOP:
6681 
        break
6682 
      if fid == 1:
6683 
        if ftype == TType.LIST:
6684 
          self.statuses = []
6685 
          (_etype38, _size35) = iprot.readListBegin()
6686 
          for _i39 in xrange(_size35):
6687 
            _elem40 = iprot.readI32();
6688 
            self.statuses.append(_elem40)
6689 
          iprot.readListEnd()
6690 
        else:
6691 
          iprot.skip(ftype)
6692 
      elif fid == 2:
6693 
        if ftype == TType.I64:
6694 
          self.offset = iprot.readI64();
6695 
        else:
6696 
          iprot.skip(ftype)
6697 
      elif fid == 3:
6698 
        if ftype == TType.I64:
6699 
          self.limit = iprot.readI64();
6700 
        else:
6701 
          iprot.skip(ftype)
6702 
      elif fid == 4:
6703 
        if ftype == TType.I64:
6704 
          self.warehouse_id = iprot.readI64();
6705 
        else:
6706 
          iprot.skip(ftype)
6707 
      else:
6708 
        iprot.skip(ftype)
6709 
      iprot.readFieldEnd()
6710 
    iprot.readStructEnd()
6711 
 
6712 
  def write(self, oprot):
6713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6715 
      return
6716 
    oprot.writeStructBegin('getOrdersInBatch_args')
6717 
    if self.statuses is not None:
6718 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6719 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6720 
      for iter41 in self.statuses:
6721 
        oprot.writeI32(iter41)
6722 
      oprot.writeListEnd()
6723 
      oprot.writeFieldEnd()
6724 
    if self.offset is not None:
6725 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6726 
      oprot.writeI64(self.offset)
6727 
      oprot.writeFieldEnd()
6728 
    if self.limit is not None:
6729 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6730 
      oprot.writeI64(self.limit)
6731 
      oprot.writeFieldEnd()
6732 
    if self.warehouse_id is not None:
6733 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6734 
      oprot.writeI64(self.warehouse_id)
6735 
      oprot.writeFieldEnd()
6736 
    oprot.writeFieldStop()
6737 
    oprot.writeStructEnd()
6738 
 
6739 
  def validate(self):
6740 
    return
6741 
 
6742 
 
6743 
  def __repr__(self):
6744 
    L = ['%s=%r' % (key, value)
6745 
      for key, value in self.__dict__.iteritems()]
6746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6747 
 
6748 
  def __eq__(self, other):
6749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6750 
 
6751 
  def __ne__(self, other):
6752 
    return not (self == other)
6753 
 
6754 
class getOrdersInBatch_result:
6755 
  """
6756 
  Attributes:
6757 
   - success
6758 
   - ex
6759 
  """
6760 
 
6761 
  thrift_spec = (
6762 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6764 
  )
6765 
 
6766 
  def __init__(self, success=None, ex=None,):
6767 
    self.success = success
6768 
    self.ex = ex
6769 
 
6770 
  def read(self, iprot):
6771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6773 
      return
6774 
    iprot.readStructBegin()
6775 
    while True:
6776 
      (fname, ftype, fid) = iprot.readFieldBegin()
6777 
      if ftype == TType.STOP:
6778 
        break
6779 
      if fid == 0:
6780 
        if ftype == TType.LIST:
6781 
          self.success = []
6782 
          (_etype45, _size42) = iprot.readListBegin()
6783 
          for _i46 in xrange(_size42):
6784 
            _elem47 = Order()
6785 
            _elem47.read(iprot)
6786 
            self.success.append(_elem47)
6787 
          iprot.readListEnd()
6788 
        else:
6789 
          iprot.skip(ftype)
6790 
      elif fid == 1:
6791 
        if ftype == TType.STRUCT:
6792 
          self.ex = TransactionServiceException()
6793 
          self.ex.read(iprot)
6794 
        else:
6795 
          iprot.skip(ftype)
6796 
      else:
6797 
        iprot.skip(ftype)
6798 
      iprot.readFieldEnd()
6799 
    iprot.readStructEnd()
6800 
 
6801 
  def write(self, oprot):
6802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6804 
      return
6805 
    oprot.writeStructBegin('getOrdersInBatch_result')
6806 
    if self.success is not None:
6807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6809 
      for iter48 in self.success:
6810 
        iter48.write(oprot)
6811 
      oprot.writeListEnd()
6812 
      oprot.writeFieldEnd()
6813 
    if self.ex is not None:
6814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6815 
      self.ex.write(oprot)
6816 
      oprot.writeFieldEnd()
6817 
    oprot.writeFieldStop()
6818 
    oprot.writeStructEnd()
6819 
 
6820 
  def validate(self):
6821 
    return
6822 
 
6823 
 
6824 
  def __repr__(self):
6825 
    L = ['%s=%r' % (key, value)
6826 
      for key, value in self.__dict__.iteritems()]
6827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6828 
 
6829 
  def __eq__(self, other):
6830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6831 
 
6832 
  def __ne__(self, other):
6833 
    return not (self == other)
6834 
 
6835 
class getOrderCount_args:
6836 
  """
6837 
  Attributes:
6838 
   - statuses
6839 
   - warehouseId
6840 
  """
6841 
 
6842 
  thrift_spec = (
6843 
    None, # 0
6844 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6845 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6846 
  )
6847 
 
6848 
  def __init__(self, statuses=None, warehouseId=None,):
6849 
    self.statuses = statuses
6850 
    self.warehouseId = warehouseId
6851 
 
6852 
  def read(self, iprot):
6853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6855 
      return
6856 
    iprot.readStructBegin()
6857 
    while True:
6858 
      (fname, ftype, fid) = iprot.readFieldBegin()
6859 
      if ftype == TType.STOP:
6860 
        break
6861 
      if fid == 1:
6862 
        if ftype == TType.LIST:
6863 
          self.statuses = []
6864 
          (_etype52, _size49) = iprot.readListBegin()
6865 
          for _i53 in xrange(_size49):
6866 
            _elem54 = iprot.readI32();
6867 
            self.statuses.append(_elem54)
6868 
          iprot.readListEnd()
6869 
        else:
6870 
          iprot.skip(ftype)
6871 
      elif fid == 2:
6872 
        if ftype == TType.I64:
6873 
          self.warehouseId = iprot.readI64();
6874 
        else:
6875 
          iprot.skip(ftype)
6876 
      else:
6877 
        iprot.skip(ftype)
6878 
      iprot.readFieldEnd()
6879 
    iprot.readStructEnd()
6880 
 
6881 
  def write(self, oprot):
6882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6884 
      return
6885 
    oprot.writeStructBegin('getOrderCount_args')
6886 
    if self.statuses is not None:
6887 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6888 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6889 
      for iter55 in self.statuses:
6890 
        oprot.writeI32(iter55)
6891 
      oprot.writeListEnd()
6892 
      oprot.writeFieldEnd()
6893 
    if self.warehouseId is not None:
6894 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6895 
      oprot.writeI64(self.warehouseId)
6896 
      oprot.writeFieldEnd()
6897 
    oprot.writeFieldStop()
6898 
    oprot.writeStructEnd()
6899 
 
6900 
  def validate(self):
6901 
    return
6902 
 
6903 
 
6904 
  def __repr__(self):
6905 
    L = ['%s=%r' % (key, value)
6906 
      for key, value in self.__dict__.iteritems()]
6907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6908 
 
6909 
  def __eq__(self, other):
6910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6911 
 
6912 
  def __ne__(self, other):
6913 
    return not (self == other)
6914 
 
6915 
class getOrderCount_result:
6916 
  """
6917 
  Attributes:
6918 
   - success
6919 
   - ex
6920 
  """
6921 
 
6922 
  thrift_spec = (
6923 
    (0, TType.I32, 'success', None, None, ), # 0
6924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6925 
  )
6926 
 
6927 
  def __init__(self, success=None, ex=None,):
6928 
    self.success = success
6929 
    self.ex = ex
6930 
 
6931 
  def read(self, iprot):
6932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6934 
      return
6935 
    iprot.readStructBegin()
6936 
    while True:
6937 
      (fname, ftype, fid) = iprot.readFieldBegin()
6938 
      if ftype == TType.STOP:
6939 
        break
6940 
      if fid == 0:
6941 
        if ftype == TType.I32:
6942 
          self.success = iprot.readI32();
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      elif fid == 1:
6946 
        if ftype == TType.STRUCT:
6947 
          self.ex = TransactionServiceException()
6948 
          self.ex.read(iprot)
6949 
        else:
6950 
          iprot.skip(ftype)
6951 
      else:
6952 
        iprot.skip(ftype)
6953 
      iprot.readFieldEnd()
6954 
    iprot.readStructEnd()
6955 
 
6956 
  def write(self, oprot):
6957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6959 
      return
6960 
    oprot.writeStructBegin('getOrderCount_result')
6961 
    if self.success is not None:
6962 
      oprot.writeFieldBegin('success', TType.I32, 0)
6963 
      oprot.writeI32(self.success)
6964 
      oprot.writeFieldEnd()
6965 
    if self.ex is not None:
6966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6967 
      self.ex.write(oprot)
6968 
      oprot.writeFieldEnd()
6969 
    oprot.writeFieldStop()
6970 
    oprot.writeStructEnd()
6971 
 
6972 
  def validate(self):
6973 
    return
6974 
 
6975 
 
6976 
  def __repr__(self):
6977 
    L = ['%s=%r' % (key, value)
6978 
      for key, value in self.__dict__.iteritems()]
6979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6980 
 
6981 
  def __eq__(self, other):
6982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6983 
 
6984 
  def __ne__(self, other):
6985 
    return not (self == other)
6986 
 
999 varun.gupt 6987 
class getOrdersByBillingDate_args:
6988 
  """
6989 
  Attributes:
6990 
   - status
6991 
   - start_billing_date
6992 
   - end_billing_date
6993 
   - warehouse_id
6994 
  """
6995 
 
6996 
  thrift_spec = (
6997 
    None, # 0
6998 
    (1, TType.I32, 'status', None, None, ), # 1
6999 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7000 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7001 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7002 
  )
7003 
 
7004 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7005 
    self.status = status
7006 
    self.start_billing_date = start_billing_date
7007 
    self.end_billing_date = end_billing_date
7008 
    self.warehouse_id = warehouse_id
7009 
 
7010 
  def read(self, iprot):
7011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7013 
      return
7014 
    iprot.readStructBegin()
7015 
    while True:
7016 
      (fname, ftype, fid) = iprot.readFieldBegin()
7017 
      if ftype == TType.STOP:
7018 
        break
7019 
      if fid == 1:
7020 
        if ftype == TType.I32:
7021 
          self.status = iprot.readI32();
7022 
        else:
7023 
          iprot.skip(ftype)
7024 
      elif fid == 2:
7025 
        if ftype == TType.I64:
7026 
          self.start_billing_date = iprot.readI64();
7027 
        else:
7028 
          iprot.skip(ftype)
7029 
      elif fid == 3:
7030 
        if ftype == TType.I64:
7031 
          self.end_billing_date = iprot.readI64();
7032 
        else:
7033 
          iprot.skip(ftype)
7034 
      elif fid == 4:
7035 
        if ftype == TType.I64:
7036 
          self.warehouse_id = iprot.readI64();
7037 
        else:
7038 
          iprot.skip(ftype)
7039 
      else:
7040 
        iprot.skip(ftype)
7041 
      iprot.readFieldEnd()
7042 
    iprot.readStructEnd()
7043 
 
7044 
  def write(self, oprot):
7045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7047 
      return
7048 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7049 
    if self.status is not None:
999 varun.gupt 7050 
      oprot.writeFieldBegin('status', TType.I32, 1)
7051 
      oprot.writeI32(self.status)
7052 
      oprot.writeFieldEnd()
3431 rajveer 7053 
    if self.start_billing_date is not None:
999 varun.gupt 7054 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7055 
      oprot.writeI64(self.start_billing_date)
7056 
      oprot.writeFieldEnd()
3431 rajveer 7057 
    if self.end_billing_date is not None:
999 varun.gupt 7058 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7059 
      oprot.writeI64(self.end_billing_date)
7060 
      oprot.writeFieldEnd()
3431 rajveer 7061 
    if self.warehouse_id is not None:
999 varun.gupt 7062 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7063 
      oprot.writeI64(self.warehouse_id)
7064 
      oprot.writeFieldEnd()
7065 
    oprot.writeFieldStop()
7066 
    oprot.writeStructEnd()
7067 
 
3431 rajveer 7068 
  def validate(self):
7069 
    return
7070 
 
7071 
 
999 varun.gupt 7072 
  def __repr__(self):
7073 
    L = ['%s=%r' % (key, value)
7074 
      for key, value in self.__dict__.iteritems()]
7075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7076 
 
7077 
  def __eq__(self, other):
7078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7079 
 
7080 
  def __ne__(self, other):
7081 
    return not (self == other)
7082 
 
7083 
class getOrdersByBillingDate_result:
7084 
  """
7085 
  Attributes:
7086 
   - success
7087 
   - ex
7088 
  """
7089 
 
7090 
  thrift_spec = (
7091 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7093 
  )
7094 
 
7095 
  def __init__(self, success=None, ex=None,):
7096 
    self.success = success
7097 
    self.ex = ex
7098 
 
7099 
  def read(self, iprot):
7100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7102 
      return
7103 
    iprot.readStructBegin()
7104 
    while True:
7105 
      (fname, ftype, fid) = iprot.readFieldBegin()
7106 
      if ftype == TType.STOP:
7107 
        break
7108 
      if fid == 0:
7109 
        if ftype == TType.LIST:
7110 
          self.success = []
4133 chandransh 7111 
          (_etype59, _size56) = iprot.readListBegin()
7112 
          for _i60 in xrange(_size56):
7113 
            _elem61 = Order()
7114 
            _elem61.read(iprot)
7115 
            self.success.append(_elem61)
999 varun.gupt 7116 
          iprot.readListEnd()
7117 
        else:
7118 
          iprot.skip(ftype)
7119 
      elif fid == 1:
7120 
        if ftype == TType.STRUCT:
7121 
          self.ex = TransactionServiceException()
7122 
          self.ex.read(iprot)
7123 
        else:
7124 
          iprot.skip(ftype)
7125 
      else:
7126 
        iprot.skip(ftype)
7127 
      iprot.readFieldEnd()
7128 
    iprot.readStructEnd()
7129 
 
7130 
  def write(self, oprot):
7131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7133 
      return
7134 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7135 
    if self.success is not None:
999 varun.gupt 7136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7138 
      for iter62 in self.success:
7139 
        iter62.write(oprot)
999 varun.gupt 7140 
      oprot.writeListEnd()
7141 
      oprot.writeFieldEnd()
3431 rajveer 7142 
    if self.ex is not None:
999 varun.gupt 7143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7144 
      self.ex.write(oprot)
7145 
      oprot.writeFieldEnd()
7146 
    oprot.writeFieldStop()
7147 
    oprot.writeStructEnd()
7148 
 
3431 rajveer 7149 
  def validate(self):
7150 
    return
7151 
 
7152 
 
999 varun.gupt 7153 
  def __repr__(self):
7154 
    L = ['%s=%r' % (key, value)
7155 
      for key, value in self.__dict__.iteritems()]
7156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7157 
 
7158 
  def __eq__(self, other):
7159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7160 
 
7161 
  def __ne__(self, other):
7162 
    return not (self == other)
7163 
 
3427 chandransh 7164 
class getOrdersByShippingDate_args:
7165 
  """
7166 
  Attributes:
7167 
   - fromShippingDate
7168 
   - toShippingDate
7169 
   - providerId
7170 
   - warehouseId
3451 chandransh 7171 
   - cod
3427 chandransh 7172 
  """
7173 
 
7174 
  thrift_spec = (
7175 
    None, # 0
7176 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7177 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7178 
    (3, TType.I64, 'providerId', None, None, ), # 3
7179 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7180 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7181 
  )
7182 
 
3451 chandransh 7183 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7184 
    self.fromShippingDate = fromShippingDate
7185 
    self.toShippingDate = toShippingDate
7186 
    self.providerId = providerId
7187 
    self.warehouseId = warehouseId
3451 chandransh 7188 
    self.cod = cod
3427 chandransh 7189 
 
7190 
  def read(self, iprot):
7191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7193 
      return
7194 
    iprot.readStructBegin()
7195 
    while True:
7196 
      (fname, ftype, fid) = iprot.readFieldBegin()
7197 
      if ftype == TType.STOP:
7198 
        break
7199 
      if fid == 1:
7200 
        if ftype == TType.I64:
7201 
          self.fromShippingDate = iprot.readI64();
7202 
        else:
7203 
          iprot.skip(ftype)
7204 
      elif fid == 2:
7205 
        if ftype == TType.I64:
7206 
          self.toShippingDate = iprot.readI64();
7207 
        else:
7208 
          iprot.skip(ftype)
7209 
      elif fid == 3:
7210 
        if ftype == TType.I64:
7211 
          self.providerId = iprot.readI64();
7212 
        else:
7213 
          iprot.skip(ftype)
7214 
      elif fid == 4:
7215 
        if ftype == TType.I64:
7216 
          self.warehouseId = iprot.readI64();
7217 
        else:
7218 
          iprot.skip(ftype)
3451 chandransh 7219 
      elif fid == 5:
7220 
        if ftype == TType.BOOL:
7221 
          self.cod = iprot.readBool();
7222 
        else:
7223 
          iprot.skip(ftype)
3427 chandransh 7224 
      else:
7225 
        iprot.skip(ftype)
7226 
      iprot.readFieldEnd()
7227 
    iprot.readStructEnd()
7228 
 
7229 
  def write(self, oprot):
7230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7232 
      return
7233 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7234 
    if self.fromShippingDate is not None:
3427 chandransh 7235 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7236 
      oprot.writeI64(self.fromShippingDate)
7237 
      oprot.writeFieldEnd()
3431 rajveer 7238 
    if self.toShippingDate is not None:
3427 chandransh 7239 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7240 
      oprot.writeI64(self.toShippingDate)
7241 
      oprot.writeFieldEnd()
3431 rajveer 7242 
    if self.providerId is not None:
3427 chandransh 7243 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7244 
      oprot.writeI64(self.providerId)
7245 
      oprot.writeFieldEnd()
3431 rajveer 7246 
    if self.warehouseId is not None:
3427 chandransh 7247 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7248 
      oprot.writeI64(self.warehouseId)
7249 
      oprot.writeFieldEnd()
3451 chandransh 7250 
    if self.cod is not None:
7251 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7252 
      oprot.writeBool(self.cod)
7253 
      oprot.writeFieldEnd()
3427 chandransh 7254 
    oprot.writeFieldStop()
7255 
    oprot.writeStructEnd()
7256 
 
3431 rajveer 7257 
  def validate(self):
7258 
    return
7259 
 
7260 
 
3427 chandransh 7261 
  def __repr__(self):
7262 
    L = ['%s=%r' % (key, value)
7263 
      for key, value in self.__dict__.iteritems()]
7264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7265 
 
7266 
  def __eq__(self, other):
7267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7268 
 
7269 
  def __ne__(self, other):
7270 
    return not (self == other)
7271 
 
7272 
class getOrdersByShippingDate_result:
7273 
  """
7274 
  Attributes:
7275 
   - success
7276 
   - ex
7277 
  """
7278 
 
7279 
  thrift_spec = (
7280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7282 
  )
7283 
 
7284 
  def __init__(self, success=None, ex=None,):
7285 
    self.success = success
7286 
    self.ex = ex
7287 
 
7288 
  def read(self, iprot):
7289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7291 
      return
7292 
    iprot.readStructBegin()
7293 
    while True:
7294 
      (fname, ftype, fid) = iprot.readFieldBegin()
7295 
      if ftype == TType.STOP:
7296 
        break
7297 
      if fid == 0:
7298 
        if ftype == TType.LIST:
7299 
          self.success = []
4133 chandransh 7300 
          (_etype66, _size63) = iprot.readListBegin()
7301 
          for _i67 in xrange(_size63):
7302 
            _elem68 = Order()
7303 
            _elem68.read(iprot)
7304 
            self.success.append(_elem68)
3427 chandransh 7305 
          iprot.readListEnd()
7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      elif fid == 1:
7309 
        if ftype == TType.STRUCT:
7310 
          self.ex = TransactionServiceException()
7311 
          self.ex.read(iprot)
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      else:
7315 
        iprot.skip(ftype)
7316 
      iprot.readFieldEnd()
7317 
    iprot.readStructEnd()
7318 
 
7319 
  def write(self, oprot):
7320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7322 
      return
7323 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7324 
    if self.success is not None:
3427 chandransh 7325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7327 
      for iter69 in self.success:
7328 
        iter69.write(oprot)
3427 chandransh 7329 
      oprot.writeListEnd()
7330 
      oprot.writeFieldEnd()
3431 rajveer 7331 
    if self.ex is not None:
3427 chandransh 7332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7333 
      self.ex.write(oprot)
7334 
      oprot.writeFieldEnd()
7335 
    oprot.writeFieldStop()
7336 
    oprot.writeStructEnd()
7337 
 
3431 rajveer 7338 
  def validate(self):
7339 
    return
7340 
 
7341 
 
3427 chandransh 7342 
  def __repr__(self):
7343 
    L = ['%s=%r' % (key, value)
7344 
      for key, value in self.__dict__.iteritems()]
7345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7346 
 
7347 
  def __eq__(self, other):
7348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7349 
 
7350 
  def __ne__(self, other):
7351 
    return not (self == other)
7352 
 
1382 varun.gupt 7353 
class getReturnableOrdersForCustomer_args:
7354 
  """
7355 
  Attributes:
7356 
   - customer_id
7357 
   - limit
7358 
  """
7359 
 
7360 
  thrift_spec = (
7361 
    None, # 0
7362 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7363 
    (2, TType.I64, 'limit', None, None, ), # 2
7364 
  )
7365 
 
7366 
  def __init__(self, customer_id=None, limit=None,):
7367 
    self.customer_id = customer_id
7368 
    self.limit = limit
7369 
 
7370 
  def read(self, iprot):
7371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7373 
      return
7374 
    iprot.readStructBegin()
7375 
    while True:
7376 
      (fname, ftype, fid) = iprot.readFieldBegin()
7377 
      if ftype == TType.STOP:
7378 
        break
7379 
      if fid == 1:
7380 
        if ftype == TType.I64:
7381 
          self.customer_id = iprot.readI64();
7382 
        else:
7383 
          iprot.skip(ftype)
7384 
      elif fid == 2:
7385 
        if ftype == TType.I64:
7386 
          self.limit = iprot.readI64();
7387 
        else:
7388 
          iprot.skip(ftype)
7389 
      else:
7390 
        iprot.skip(ftype)
7391 
      iprot.readFieldEnd()
7392 
    iprot.readStructEnd()
7393 
 
7394 
  def write(self, oprot):
7395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7397 
      return
7398 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7399 
    if self.customer_id is not None:
1382 varun.gupt 7400 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7401 
      oprot.writeI64(self.customer_id)
7402 
      oprot.writeFieldEnd()
3431 rajveer 7403 
    if self.limit is not None:
1382 varun.gupt 7404 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7405 
      oprot.writeI64(self.limit)
7406 
      oprot.writeFieldEnd()
7407 
    oprot.writeFieldStop()
7408 
    oprot.writeStructEnd()
7409 
 
3431 rajveer 7410 
  def validate(self):
7411 
    return
7412 
 
7413 
 
1382 varun.gupt 7414 
  def __repr__(self):
7415 
    L = ['%s=%r' % (key, value)
7416 
      for key, value in self.__dict__.iteritems()]
7417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7418 
 
7419 
  def __eq__(self, other):
7420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7421 
 
7422 
  def __ne__(self, other):
7423 
    return not (self == other)
7424 
 
7425 
class getReturnableOrdersForCustomer_result:
7426 
  """
7427 
  Attributes:
7428 
   - success
7429 
   - ex
7430 
  """
7431 
 
7432 
  thrift_spec = (
7433 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7435 
  )
7436 
 
7437 
  def __init__(self, success=None, ex=None,):
7438 
    self.success = success
7439 
    self.ex = ex
7440 
 
7441 
  def read(self, iprot):
7442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7444 
      return
7445 
    iprot.readStructBegin()
7446 
    while True:
7447 
      (fname, ftype, fid) = iprot.readFieldBegin()
7448 
      if ftype == TType.STOP:
7449 
        break
7450 
      if fid == 0:
7451 
        if ftype == TType.LIST:
7452 
          self.success = []
4133 chandransh 7453 
          (_etype73, _size70) = iprot.readListBegin()
7454 
          for _i74 in xrange(_size70):
7455 
            _elem75 = iprot.readI64();
7456 
            self.success.append(_elem75)
1382 varun.gupt 7457 
          iprot.readListEnd()
7458 
        else:
7459 
          iprot.skip(ftype)
7460 
      elif fid == 1:
7461 
        if ftype == TType.STRUCT:
7462 
          self.ex = TransactionServiceException()
7463 
          self.ex.read(iprot)
7464 
        else:
7465 
          iprot.skip(ftype)
7466 
      else:
7467 
        iprot.skip(ftype)
7468 
      iprot.readFieldEnd()
7469 
    iprot.readStructEnd()
7470 
 
7471 
  def write(self, oprot):
7472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7474 
      return
7475 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7476 
    if self.success is not None:
1382 varun.gupt 7477 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7478 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7479 
      for iter76 in self.success:
7480 
        oprot.writeI64(iter76)
1382 varun.gupt 7481 
      oprot.writeListEnd()
7482 
      oprot.writeFieldEnd()
3431 rajveer 7483 
    if self.ex is not None:
1382 varun.gupt 7484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7485 
      self.ex.write(oprot)
7486 
      oprot.writeFieldEnd()
7487 
    oprot.writeFieldStop()
7488 
    oprot.writeStructEnd()
7489 
 
3431 rajveer 7490 
  def validate(self):
7491 
    return
7492 
 
7493 
 
1382 varun.gupt 7494 
  def __repr__(self):
7495 
    L = ['%s=%r' % (key, value)
7496 
      for key, value in self.__dict__.iteritems()]
7497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7498 
 
7499 
  def __eq__(self, other):
7500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7501 
 
7502 
  def __ne__(self, other):
7503 
    return not (self == other)
7504 
 
7505 
class getCancellableOrdersForCustomer_args:
7506 
  """
7507 
  Attributes:
7508 
   - customer_id
7509 
   - limit
7510 
  """
7511 
 
7512 
  thrift_spec = (
7513 
    None, # 0
7514 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7515 
    (2, TType.I64, 'limit', None, None, ), # 2
7516 
  )
7517 
 
7518 
  def __init__(self, customer_id=None, limit=None,):
7519 
    self.customer_id = customer_id
7520 
    self.limit = limit
7521 
 
7522 
  def read(self, iprot):
7523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7525 
      return
7526 
    iprot.readStructBegin()
7527 
    while True:
7528 
      (fname, ftype, fid) = iprot.readFieldBegin()
7529 
      if ftype == TType.STOP:
7530 
        break
7531 
      if fid == 1:
7532 
        if ftype == TType.I64:
7533 
          self.customer_id = iprot.readI64();
7534 
        else:
7535 
          iprot.skip(ftype)
7536 
      elif fid == 2:
7537 
        if ftype == TType.I64:
7538 
          self.limit = iprot.readI64();
7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      else:
7542 
        iprot.skip(ftype)
7543 
      iprot.readFieldEnd()
7544 
    iprot.readStructEnd()
7545 
 
7546 
  def write(self, oprot):
7547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7549 
      return
7550 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7551 
    if self.customer_id is not None:
1382 varun.gupt 7552 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7553 
      oprot.writeI64(self.customer_id)
7554 
      oprot.writeFieldEnd()
3431 rajveer 7555 
    if self.limit is not None:
1382 varun.gupt 7556 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7557 
      oprot.writeI64(self.limit)
7558 
      oprot.writeFieldEnd()
7559 
    oprot.writeFieldStop()
7560 
    oprot.writeStructEnd()
7561 
 
3431 rajveer 7562 
  def validate(self):
7563 
    return
7564 
 
7565 
 
1382 varun.gupt 7566 
  def __repr__(self):
7567 
    L = ['%s=%r' % (key, value)
7568 
      for key, value in self.__dict__.iteritems()]
7569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7570 
 
7571 
  def __eq__(self, other):
7572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7573 
 
7574 
  def __ne__(self, other):
7575 
    return not (self == other)
7576 
 
7577 
class getCancellableOrdersForCustomer_result:
7578 
  """
7579 
  Attributes:
7580 
   - success
7581 
   - ex
7582 
  """
7583 
 
7584 
  thrift_spec = (
7585 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7587 
  )
7588 
 
7589 
  def __init__(self, success=None, ex=None,):
7590 
    self.success = success
7591 
    self.ex = ex
7592 
 
7593 
  def read(self, iprot):
7594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7596 
      return
7597 
    iprot.readStructBegin()
7598 
    while True:
7599 
      (fname, ftype, fid) = iprot.readFieldBegin()
7600 
      if ftype == TType.STOP:
7601 
        break
7602 
      if fid == 0:
7603 
        if ftype == TType.LIST:
7604 
          self.success = []
4133 chandransh 7605 
          (_etype80, _size77) = iprot.readListBegin()
7606 
          for _i81 in xrange(_size77):
7607 
            _elem82 = iprot.readI64();
7608 
            self.success.append(_elem82)
1382 varun.gupt 7609 
          iprot.readListEnd()
7610 
        else:
7611 
          iprot.skip(ftype)
7612 
      elif fid == 1:
7613 
        if ftype == TType.STRUCT:
7614 
          self.ex = TransactionServiceException()
7615 
          self.ex.read(iprot)
7616 
        else:
7617 
          iprot.skip(ftype)
7618 
      else:
7619 
        iprot.skip(ftype)
7620 
      iprot.readFieldEnd()
7621 
    iprot.readStructEnd()
7622 
 
7623 
  def write(self, oprot):
7624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7626 
      return
7627 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7628 
    if self.success is not None:
1382 varun.gupt 7629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7630 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7631 
      for iter83 in self.success:
7632 
        oprot.writeI64(iter83)
1382 varun.gupt 7633 
      oprot.writeListEnd()
7634 
      oprot.writeFieldEnd()
3431 rajveer 7635 
    if self.ex is not None:
1382 varun.gupt 7636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7637 
      self.ex.write(oprot)
7638 
      oprot.writeFieldEnd()
7639 
    oprot.writeFieldStop()
7640 
    oprot.writeStructEnd()
7641 
 
3431 rajveer 7642 
  def validate(self):
7643 
    return
7644 
 
7645 
 
1382 varun.gupt 7646 
  def __repr__(self):
7647 
    L = ['%s=%r' % (key, value)
7648 
      for key, value in self.__dict__.iteritems()]
7649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7650 
 
7651 
  def __eq__(self, other):
7652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7653 
 
7654 
  def __ne__(self, other):
7655 
    return not (self == other)
7656 
 
483 rajveer 7657 
class changeOrderStatus_args:
94 ashish 7658 
  """
7659 
  Attributes:
483 rajveer 7660 
   - orderId
7661 
   - status
7662 
   - description
94 ashish 7663 
  """
7664 
 
7665 
  thrift_spec = (
7666 
    None, # 0
483 rajveer 7667 
    (1, TType.I64, 'orderId', None, None, ), # 1
7668 
    (2, TType.I32, 'status', None, None, ), # 2
7669 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7670 
  )
7671 
 
483 rajveer 7672 
  def __init__(self, orderId=None, status=None, description=None,):
7673 
    self.orderId = orderId
7674 
    self.status = status
7675 
    self.description = description
94 ashish 7676 
 
7677 
  def read(self, iprot):
7678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7680 
      return
7681 
    iprot.readStructBegin()
7682 
    while True:
7683 
      (fname, ftype, fid) = iprot.readFieldBegin()
7684 
      if ftype == TType.STOP:
7685 
        break
7686 
      if fid == 1:
7687 
        if ftype == TType.I64:
483 rajveer 7688 
          self.orderId = iprot.readI64();
94 ashish 7689 
        else:
7690 
          iprot.skip(ftype)
7691 
      elif fid == 2:
483 rajveer 7692 
        if ftype == TType.I32:
7693 
          self.status = iprot.readI32();
94 ashish 7694 
        else:
7695 
          iprot.skip(ftype)
483 rajveer 7696 
      elif fid == 3:
7697 
        if ftype == TType.STRING:
7698 
          self.description = iprot.readString();
7699 
        else:
7700 
          iprot.skip(ftype)
94 ashish 7701 
      else:
7702 
        iprot.skip(ftype)
7703 
      iprot.readFieldEnd()
7704 
    iprot.readStructEnd()
7705 
 
7706 
  def write(self, oprot):
7707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7709 
      return
483 rajveer 7710 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7711 
    if self.orderId is not None:
483 rajveer 7712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7713 
      oprot.writeI64(self.orderId)
94 ashish 7714 
      oprot.writeFieldEnd()
3431 rajveer 7715 
    if self.status is not None:
483 rajveer 7716 
      oprot.writeFieldBegin('status', TType.I32, 2)
7717 
      oprot.writeI32(self.status)
94 ashish 7718 
      oprot.writeFieldEnd()
3431 rajveer 7719 
    if self.description is not None:
483 rajveer 7720 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7721 
      oprot.writeString(self.description)
7722 
      oprot.writeFieldEnd()
94 ashish 7723 
    oprot.writeFieldStop()
7724 
    oprot.writeStructEnd()
7725 
 
3431 rajveer 7726 
  def validate(self):
7727 
    return
7728 
 
7729 
 
94 ashish 7730 
  def __repr__(self):
7731 
    L = ['%s=%r' % (key, value)
7732 
      for key, value in self.__dict__.iteritems()]
7733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7734 
 
7735 
  def __eq__(self, other):
7736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7737 
 
7738 
  def __ne__(self, other):
7739 
    return not (self == other)
7740 
 
483 rajveer 7741 
class changeOrderStatus_result:
94 ashish 7742 
  """
7743 
  Attributes:
7744 
   - success
7745 
   - ex
7746 
  """
7747 
 
7748 
  thrift_spec = (
7749 
    (0, TType.BOOL, 'success', None, None, ), # 0
7750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7751 
  )
7752 
 
7753 
  def __init__(self, success=None, ex=None,):
7754 
    self.success = success
7755 
    self.ex = ex
7756 
 
7757 
  def read(self, iprot):
7758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7760 
      return
7761 
    iprot.readStructBegin()
7762 
    while True:
7763 
      (fname, ftype, fid) = iprot.readFieldBegin()
7764 
      if ftype == TType.STOP:
7765 
        break
7766 
      if fid == 0:
7767 
        if ftype == TType.BOOL:
7768 
          self.success = iprot.readBool();
7769 
        else:
7770 
          iprot.skip(ftype)
7771 
      elif fid == 1:
7772 
        if ftype == TType.STRUCT:
7773 
          self.ex = TransactionServiceException()
7774 
          self.ex.read(iprot)
7775 
        else:
7776 
          iprot.skip(ftype)
7777 
      else:
7778 
        iprot.skip(ftype)
7779 
      iprot.readFieldEnd()
7780 
    iprot.readStructEnd()
7781 
 
7782 
  def write(self, oprot):
7783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7785 
      return
483 rajveer 7786 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7787 
    if self.success is not None:
94 ashish 7788 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7789 
      oprot.writeBool(self.success)
7790 
      oprot.writeFieldEnd()
3431 rajveer 7791 
    if self.ex is not None:
94 ashish 7792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7793 
      self.ex.write(oprot)
7794 
      oprot.writeFieldEnd()
7795 
    oprot.writeFieldStop()
7796 
    oprot.writeStructEnd()
7797 
 
3431 rajveer 7798 
  def validate(self):
7799 
    return
7800 
 
7801 
 
94 ashish 7802 
  def __repr__(self):
7803 
    L = ['%s=%r' % (key, value)
7804 
      for key, value in self.__dict__.iteritems()]
7805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7806 
 
7807 
  def __eq__(self, other):
7808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7809 
 
7810 
  def __ne__(self, other):
7811 
    return not (self == other)
7812 
 
3064 chandransh 7813 
class getOrdersForTransaction_args:
494 rajveer 7814 
  """
7815 
  Attributes:
3064 chandransh 7816 
   - transactionId
7817 
   - customerId
494 rajveer 7818 
  """
7819 
 
7820 
  thrift_spec = (
7821 
    None, # 0
3064 chandransh 7822 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7823 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7824 
  )
7825 
 
3064 chandransh 7826 
  def __init__(self, transactionId=None, customerId=None,):
7827 
    self.transactionId = transactionId
7828 
    self.customerId = customerId
494 rajveer 7829 
 
7830 
  def read(self, iprot):
7831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7833 
      return
7834 
    iprot.readStructBegin()
7835 
    while True:
7836 
      (fname, ftype, fid) = iprot.readFieldBegin()
7837 
      if ftype == TType.STOP:
7838 
        break
7839 
      if fid == 1:
7840 
        if ftype == TType.I64:
3064 chandransh 7841 
          self.transactionId = iprot.readI64();
494 rajveer 7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      elif fid == 2:
3064 chandransh 7845 
        if ftype == TType.I64:
7846 
          self.customerId = iprot.readI64();
494 rajveer 7847 
        else:
7848 
          iprot.skip(ftype)
7849 
      else:
7850 
        iprot.skip(ftype)
7851 
      iprot.readFieldEnd()
7852 
    iprot.readStructEnd()
7853 
 
7854 
  def write(self, oprot):
7855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7857 
      return
3064 chandransh 7858 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7859 
    if self.transactionId is not None:
3064 chandransh 7860 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7861 
      oprot.writeI64(self.transactionId)
494 rajveer 7862 
      oprot.writeFieldEnd()
3431 rajveer 7863 
    if self.customerId is not None:
3064 chandransh 7864 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7865 
      oprot.writeI64(self.customerId)
494 rajveer 7866 
      oprot.writeFieldEnd()
7867 
    oprot.writeFieldStop()
7868 
    oprot.writeStructEnd()
7869 
 
3431 rajveer 7870 
  def validate(self):
7871 
    return
7872 
 
7873 
 
494 rajveer 7874 
  def __repr__(self):
7875 
    L = ['%s=%r' % (key, value)
7876 
      for key, value in self.__dict__.iteritems()]
7877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7878 
 
7879 
  def __eq__(self, other):
7880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7881 
 
7882 
  def __ne__(self, other):
7883 
    return not (self == other)
7884 
 
3064 chandransh 7885 
class getOrdersForTransaction_result:
494 rajveer 7886 
  """
7887 
  Attributes:
7888 
   - success
7889 
   - ex
7890 
  """
7891 
 
7892 
  thrift_spec = (
3064 chandransh 7893 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7895 
  )
7896 
 
7897 
  def __init__(self, success=None, ex=None,):
7898 
    self.success = success
7899 
    self.ex = ex
7900 
 
7901 
  def read(self, iprot):
7902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7904 
      return
7905 
    iprot.readStructBegin()
7906 
    while True:
7907 
      (fname, ftype, fid) = iprot.readFieldBegin()
7908 
      if ftype == TType.STOP:
7909 
        break
7910 
      if fid == 0:
3064 chandransh 7911 
        if ftype == TType.LIST:
7912 
          self.success = []
4133 chandransh 7913 
          (_etype87, _size84) = iprot.readListBegin()
7914 
          for _i88 in xrange(_size84):
7915 
            _elem89 = Order()
7916 
            _elem89.read(iprot)
7917 
            self.success.append(_elem89)
3064 chandransh 7918 
          iprot.readListEnd()
494 rajveer 7919 
        else:
7920 
          iprot.skip(ftype)
7921 
      elif fid == 1:
7922 
        if ftype == TType.STRUCT:
7923 
          self.ex = TransactionServiceException()
7924 
          self.ex.read(iprot)
7925 
        else:
7926 
          iprot.skip(ftype)
7927 
      else:
7928 
        iprot.skip(ftype)
7929 
      iprot.readFieldEnd()
7930 
    iprot.readStructEnd()
7931 
 
7932 
  def write(self, oprot):
7933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7935 
      return
3064 chandransh 7936 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7937 
    if self.success is not None:
3064 chandransh 7938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7939 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7940 
      for iter90 in self.success:
7941 
        iter90.write(oprot)
3064 chandransh 7942 
      oprot.writeListEnd()
494 rajveer 7943 
      oprot.writeFieldEnd()
3431 rajveer 7944 
    if self.ex is not None:
494 rajveer 7945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7946 
      self.ex.write(oprot)
7947 
      oprot.writeFieldEnd()
7948 
    oprot.writeFieldStop()
7949 
    oprot.writeStructEnd()
7950 
 
3431 rajveer 7951 
  def validate(self):
7952 
    return
7953 
 
7954 
 
494 rajveer 7955 
  def __repr__(self):
7956 
    L = ['%s=%r' % (key, value)
7957 
      for key, value in self.__dict__.iteritems()]
7958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7959 
 
7960 
  def __eq__(self, other):
7961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7962 
 
7963 
  def __ne__(self, other):
7964 
    return not (self == other)
7965 
 
3064 chandransh 7966 
class getOrdersForCustomer_args:
1149 chandransh 7967 
  """
7968 
  Attributes:
3064 chandransh 7969 
   - customerId
7970 
   - from_date
7971 
   - to_date
7972 
   - statuses
1149 chandransh 7973 
  """
7974 
 
7975 
  thrift_spec = (
7976 
    None, # 0
3064 chandransh 7977 
    (1, TType.I64, 'customerId', None, None, ), # 1
7978 
    (2, TType.I64, 'from_date', None, None, ), # 2
7979 
    (3, TType.I64, 'to_date', None, None, ), # 3
7980 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7981 
  )
7982 
 
3064 chandransh 7983 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7984 
    self.customerId = customerId
7985 
    self.from_date = from_date
7986 
    self.to_date = to_date
7987 
    self.statuses = statuses
1149 chandransh 7988 
 
7989 
  def read(self, iprot):
7990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7992 
      return
7993 
    iprot.readStructBegin()
7994 
    while True:
7995 
      (fname, ftype, fid) = iprot.readFieldBegin()
7996 
      if ftype == TType.STOP:
7997 
        break
7998 
      if fid == 1:
7999 
        if ftype == TType.I64:
3064 chandransh 8000 
          self.customerId = iprot.readI64();
1149 chandransh 8001 
        else:
8002 
          iprot.skip(ftype)
8003 
      elif fid == 2:
8004 
        if ftype == TType.I64:
3064 chandransh 8005 
          self.from_date = iprot.readI64();
1149 chandransh 8006 
        else:
8007 
          iprot.skip(ftype)
2783 chandransh 8008 
      elif fid == 3:
8009 
        if ftype == TType.I64:
3064 chandransh 8010 
          self.to_date = iprot.readI64();
2783 chandransh 8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      elif fid == 4:
3064 chandransh 8014 
        if ftype == TType.LIST:
8015 
          self.statuses = []
4133 chandransh 8016 
          (_etype94, _size91) = iprot.readListBegin()
8017 
          for _i95 in xrange(_size91):
8018 
            _elem96 = iprot.readI32();
8019 
            self.statuses.append(_elem96)
3064 chandransh 8020 
          iprot.readListEnd()
2783 chandransh 8021 
        else:
8022 
          iprot.skip(ftype)
1149 chandransh 8023 
      else:
8024 
        iprot.skip(ftype)
8025 
      iprot.readFieldEnd()
8026 
    iprot.readStructEnd()
8027 
 
8028 
  def write(self, oprot):
8029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8031 
      return
3064 chandransh 8032 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8033 
    if self.customerId is not None:
3064 chandransh 8034 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8035 
      oprot.writeI64(self.customerId)
1149 chandransh 8036 
      oprot.writeFieldEnd()
3431 rajveer 8037 
    if self.from_date is not None:
3064 chandransh 8038 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8039 
      oprot.writeI64(self.from_date)
1149 chandransh 8040 
      oprot.writeFieldEnd()
3431 rajveer 8041 
    if self.to_date is not None:
3064 chandransh 8042 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8043 
      oprot.writeI64(self.to_date)
2783 chandransh 8044 
      oprot.writeFieldEnd()
3431 rajveer 8045 
    if self.statuses is not None:
3064 chandransh 8046 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8047 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8048 
      for iter97 in self.statuses:
8049 
        oprot.writeI32(iter97)
3064 chandransh 8050 
      oprot.writeListEnd()
2783 chandransh 8051 
      oprot.writeFieldEnd()
1149 chandransh 8052 
    oprot.writeFieldStop()
8053 
    oprot.writeStructEnd()
8054 
 
3431 rajveer 8055 
  def validate(self):
8056 
    return
8057 
 
8058 
 
1149 chandransh 8059 
  def __repr__(self):
8060 
    L = ['%s=%r' % (key, value)
8061 
      for key, value in self.__dict__.iteritems()]
8062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8063 
 
8064 
  def __eq__(self, other):
8065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8066 
 
8067 
  def __ne__(self, other):
8068 
    return not (self == other)
8069 
 
3064 chandransh 8070 
class getOrdersForCustomer_result:
1149 chandransh 8071 
  """
8072 
  Attributes:
8073 
   - success
8074 
   - ex
8075 
  """
8076 
 
8077 
  thrift_spec = (
3064 chandransh 8078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8080 
  )
8081 
 
8082 
  def __init__(self, success=None, ex=None,):
8083 
    self.success = success
8084 
    self.ex = ex
8085 
 
8086 
  def read(self, iprot):
8087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8089 
      return
8090 
    iprot.readStructBegin()
8091 
    while True:
8092 
      (fname, ftype, fid) = iprot.readFieldBegin()
8093 
      if ftype == TType.STOP:
8094 
        break
8095 
      if fid == 0:
3064 chandransh 8096 
        if ftype == TType.LIST:
8097 
          self.success = []
4133 chandransh 8098 
          (_etype101, _size98) = iprot.readListBegin()
8099 
          for _i102 in xrange(_size98):
8100 
            _elem103 = Order()
8101 
            _elem103.read(iprot)
8102 
            self.success.append(_elem103)
3064 chandransh 8103 
          iprot.readListEnd()
1149 chandransh 8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      elif fid == 1:
8107 
        if ftype == TType.STRUCT:
8108 
          self.ex = TransactionServiceException()
8109 
          self.ex.read(iprot)
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      else:
8113 
        iprot.skip(ftype)
8114 
      iprot.readFieldEnd()
8115 
    iprot.readStructEnd()
8116 
 
8117 
  def write(self, oprot):
8118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8120 
      return
3064 chandransh 8121 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8122 
    if self.success is not None:
3064 chandransh 8123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8125 
      for iter104 in self.success:
8126 
        iter104.write(oprot)
3064 chandransh 8127 
      oprot.writeListEnd()
1149 chandransh 8128 
      oprot.writeFieldEnd()
3431 rajveer 8129 
    if self.ex is not None:
1149 chandransh 8130 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8131 
      self.ex.write(oprot)
8132 
      oprot.writeFieldEnd()
8133 
    oprot.writeFieldStop()
8134 
    oprot.writeStructEnd()
8135 
 
3431 rajveer 8136 
  def validate(self):
8137 
    return
8138 
 
8139 
 
1149 chandransh 8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
3064 chandransh 8151 
class createOrder_args:
921 rajveer 8152 
  """
8153 
  Attributes:
3064 chandransh 8154 
   - order
921 rajveer 8155 
  """
8156 
 
8157 
  thrift_spec = (
8158 
    None, # 0
3064 chandransh 8159 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8160 
  )
8161 
 
3064 chandransh 8162 
  def __init__(self, order=None,):
8163 
    self.order = order
921 rajveer 8164 
 
8165 
  def read(self, iprot):
8166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8168 
      return
8169 
    iprot.readStructBegin()
8170 
    while True:
8171 
      (fname, ftype, fid) = iprot.readFieldBegin()
8172 
      if ftype == TType.STOP:
8173 
        break
8174 
      if fid == 1:
3064 chandransh 8175 
        if ftype == TType.STRUCT:
8176 
          self.order = Order()
8177 
          self.order.read(iprot)
921 rajveer 8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      else:
8181 
        iprot.skip(ftype)
8182 
      iprot.readFieldEnd()
8183 
    iprot.readStructEnd()
8184 
 
8185 
  def write(self, oprot):
8186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8188 
      return
3064 chandransh 8189 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8190 
    if self.order is not None:
3064 chandransh 8191 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8192 
      self.order.write(oprot)
921 rajveer 8193 
      oprot.writeFieldEnd()
8194 
    oprot.writeFieldStop()
8195 
    oprot.writeStructEnd()
8196 
 
3431 rajveer 8197 
  def validate(self):
8198 
    return
8199 
 
8200 
 
921 rajveer 8201 
  def __repr__(self):
8202 
    L = ['%s=%r' % (key, value)
8203 
      for key, value in self.__dict__.iteritems()]
8204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8205 
 
8206 
  def __eq__(self, other):
8207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8208 
 
8209 
  def __ne__(self, other):
8210 
    return not (self == other)
8211 
 
3064 chandransh 8212 
class createOrder_result:
921 rajveer 8213 
  """
8214 
  Attributes:
8215 
   - success
8216 
   - ex
8217 
  """
8218 
 
8219 
  thrift_spec = (
3064 chandransh 8220 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8222 
  )
8223 
 
8224 
  def __init__(self, success=None, ex=None,):
8225 
    self.success = success
8226 
    self.ex = ex
8227 
 
8228 
  def read(self, iprot):
8229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8231 
      return
8232 
    iprot.readStructBegin()
8233 
    while True:
8234 
      (fname, ftype, fid) = iprot.readFieldBegin()
8235 
      if ftype == TType.STOP:
8236 
        break
8237 
      if fid == 0:
3064 chandransh 8238 
        if ftype == TType.I64:
8239 
          self.success = iprot.readI64();
921 rajveer 8240 
        else:
8241 
          iprot.skip(ftype)
8242 
      elif fid == 1:
8243 
        if ftype == TType.STRUCT:
8244 
          self.ex = TransactionServiceException()
8245 
          self.ex.read(iprot)
8246 
        else:
8247 
          iprot.skip(ftype)
8248 
      else:
8249 
        iprot.skip(ftype)
8250 
      iprot.readFieldEnd()
8251 
    iprot.readStructEnd()
8252 
 
8253 
  def write(self, oprot):
8254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8256 
      return
3064 chandransh 8257 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8258 
    if self.success is not None:
3064 chandransh 8259 
      oprot.writeFieldBegin('success', TType.I64, 0)
8260 
      oprot.writeI64(self.success)
921 rajveer 8261 
      oprot.writeFieldEnd()
3431 rajveer 8262 
    if self.ex is not None:
921 rajveer 8263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8264 
      self.ex.write(oprot)
8265 
      oprot.writeFieldEnd()
8266 
    oprot.writeFieldStop()
8267 
    oprot.writeStructEnd()
8268 
 
3431 rajveer 8269 
  def validate(self):
8270 
    return
8271 
 
8272 
 
921 rajveer 8273 
  def __repr__(self):
8274 
    L = ['%s=%r' % (key, value)
8275 
      for key, value in self.__dict__.iteritems()]
8276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8277 
 
8278 
  def __eq__(self, other):
8279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8280 
 
8281 
  def __ne__(self, other):
8282 
    return not (self == other)
8283 
 
3064 chandransh 8284 
class getOrder_args:
921 rajveer 8285 
  """
8286 
  Attributes:
3064 chandransh 8287 
   - id
921 rajveer 8288 
  """
8289 
 
8290 
  thrift_spec = (
8291 
    None, # 0
3064 chandransh 8292 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8293 
  )
8294 
 
3064 chandransh 8295 
  def __init__(self, id=None,):
8296 
    self.id = id
921 rajveer 8297 
 
8298 
  def read(self, iprot):
8299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8301 
      return
8302 
    iprot.readStructBegin()
8303 
    while True:
8304 
      (fname, ftype, fid) = iprot.readFieldBegin()
8305 
      if ftype == TType.STOP:
8306 
        break
8307 
      if fid == 1:
8308 
        if ftype == TType.I64:
3064 chandransh 8309 
          self.id = iprot.readI64();
921 rajveer 8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      else:
8313 
        iprot.skip(ftype)
8314 
      iprot.readFieldEnd()
8315 
    iprot.readStructEnd()
8316 
 
8317 
  def write(self, oprot):
8318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8320 
      return
3064 chandransh 8321 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8322 
    if self.id is not None:
3064 chandransh 8323 
      oprot.writeFieldBegin('id', TType.I64, 1)
8324 
      oprot.writeI64(self.id)
921 rajveer 8325 
      oprot.writeFieldEnd()
8326 
    oprot.writeFieldStop()
8327 
    oprot.writeStructEnd()
8328 
 
3431 rajveer 8329 
  def validate(self):
8330 
    return
8331 
 
8332 
 
921 rajveer 8333 
  def __repr__(self):
8334 
    L = ['%s=%r' % (key, value)
8335 
      for key, value in self.__dict__.iteritems()]
8336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8337 
 
8338 
  def __eq__(self, other):
8339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8340 
 
8341 
  def __ne__(self, other):
8342 
    return not (self == other)
8343 
 
3064 chandransh 8344 
class getOrder_result:
921 rajveer 8345 
  """
8346 
  Attributes:
8347 
   - success
8348 
   - ex
8349 
  """
8350 
 
8351 
  thrift_spec = (
3064 chandransh 8352 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8354 
  )
8355 
 
8356 
  def __init__(self, success=None, ex=None,):
8357 
    self.success = success
8358 
    self.ex = ex
8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      if fid == 0:
3064 chandransh 8370 
        if ftype == TType.STRUCT:
8371 
          self.success = Order()
8372 
          self.success.read(iprot)
921 rajveer 8373 
        else:
8374 
          iprot.skip(ftype)
8375 
      elif fid == 1:
8376 
        if ftype == TType.STRUCT:
8377 
          self.ex = TransactionServiceException()
8378 
          self.ex.read(iprot)
8379 
        else:
8380 
          iprot.skip(ftype)
8381 
      else:
8382 
        iprot.skip(ftype)
8383 
      iprot.readFieldEnd()
8384 
    iprot.readStructEnd()
8385 
 
8386 
  def write(self, oprot):
8387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8389 
      return
3064 chandransh 8390 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8391 
    if self.success is not None:
3064 chandransh 8392 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8393 
      self.success.write(oprot)
921 rajveer 8394 
      oprot.writeFieldEnd()
3431 rajveer 8395 
    if self.ex is not None:
921 rajveer 8396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8397 
      self.ex.write(oprot)
8398 
      oprot.writeFieldEnd()
8399 
    oprot.writeFieldStop()
8400 
    oprot.writeStructEnd()
8401 
 
3431 rajveer 8402 
  def validate(self):
8403 
    return
8404 
 
8405 
 
921 rajveer 8406 
  def __repr__(self):
8407 
    L = ['%s=%r' % (key, value)
8408 
      for key, value in self.__dict__.iteritems()]
8409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8410 
 
8411 
  def __eq__(self, other):
8412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8413 
 
8414 
  def __ne__(self, other):
8415 
    return not (self == other)
8416 
 
3064 chandransh 8417 
class getLineItemsForOrder_args:
94 ashish 8418 
  """
8419 
  Attributes:
3064 chandransh 8420 
   - orderId
94 ashish 8421 
  """
8422 
 
8423 
  thrift_spec = (
8424 
    None, # 0
3064 chandransh 8425 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8426 
  )
8427 
 
3064 chandransh 8428 
  def __init__(self, orderId=None,):
8429 
    self.orderId = orderId
94 ashish 8430 
 
8431 
  def read(self, iprot):
8432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8434 
      return
8435 
    iprot.readStructBegin()
8436 
    while True:
8437 
      (fname, ftype, fid) = iprot.readFieldBegin()
8438 
      if ftype == TType.STOP:
8439 
        break
8440 
      if fid == 1:
8441 
        if ftype == TType.I64:
3064 chandransh 8442 
          self.orderId = iprot.readI64();
94 ashish 8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
3064 chandransh 8454 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8455 
    if self.orderId is not None:
3064 chandransh 8456 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8457 
      oprot.writeI64(self.orderId)
94 ashish 8458 
      oprot.writeFieldEnd()
8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
3431 rajveer 8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
94 ashish 8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
3064 chandransh 8477 
class getLineItemsForOrder_result:
94 ashish 8478 
  """
8479 
  Attributes:
8480 
   - success
8481 
   - ex
8482 
  """
8483 
 
8484 
  thrift_spec = (
3064 chandransh 8485 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8487 
  )
8488 
 
8489 
  def __init__(self, success=None, ex=None,):
8490 
    self.success = success
8491 
    self.ex = ex
8492 
 
8493 
  def read(self, iprot):
8494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8496 
      return
8497 
    iprot.readStructBegin()
8498 
    while True:
8499 
      (fname, ftype, fid) = iprot.readFieldBegin()
8500 
      if ftype == TType.STOP:
8501 
        break
8502 
      if fid == 0:
483 rajveer 8503 
        if ftype == TType.LIST:
8504 
          self.success = []
4133 chandransh 8505 
          (_etype108, _size105) = iprot.readListBegin()
8506 
          for _i109 in xrange(_size105):
8507 
            _elem110 = LineItem()
8508 
            _elem110.read(iprot)
8509 
            self.success.append(_elem110)
483 rajveer 8510 
          iprot.readListEnd()
94 ashish 8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.ex = TransactionServiceException()
8516 
          self.ex.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
3064 chandransh 8528 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8529 
    if self.success is not None:
483 rajveer 8530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8532 
      for iter111 in self.success:
8533 
        iter111.write(oprot)
483 rajveer 8534 
      oprot.writeListEnd()
94 ashish 8535 
      oprot.writeFieldEnd()
3431 rajveer 8536 
    if self.ex is not None:
94 ashish 8537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8538 
      self.ex.write(oprot)
8539 
      oprot.writeFieldEnd()
8540 
    oprot.writeFieldStop()
8541 
    oprot.writeStructEnd()
8542 
 
3431 rajveer 8543 
  def validate(self):
8544 
    return
8545 
 
8546 
 
94 ashish 8547 
  def __repr__(self):
8548 
    L = ['%s=%r' % (key, value)
8549 
      for key, value in self.__dict__.iteritems()]
8550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8551 
 
8552 
  def __eq__(self, other):
8553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8554 
 
8555 
  def __ne__(self, other):
8556 
    return not (self == other)
8557 
 
3064 chandransh 8558 
class getOrderForCustomer_args:
94 ashish 8559 
  """
8560 
  Attributes:
3064 chandransh 8561 
   - orderId
483 rajveer 8562 
   - customerId
94 ashish 8563 
  """
8564 
 
8565 
  thrift_spec = (
8566 
    None, # 0
3064 chandransh 8567 
    (1, TType.I64, 'orderId', None, None, ), # 1
8568 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8569 
  )
8570 
 
3064 chandransh 8571 
  def __init__(self, orderId=None, customerId=None,):
8572 
    self.orderId = orderId
483 rajveer 8573 
    self.customerId = customerId
94 ashish 8574 
 
8575 
  def read(self, iprot):
8576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8578 
      return
8579 
    iprot.readStructBegin()
8580 
    while True:
8581 
      (fname, ftype, fid) = iprot.readFieldBegin()
8582 
      if ftype == TType.STOP:
8583 
        break
8584 
      if fid == 1:
8585 
        if ftype == TType.I64:
3064 chandransh 8586 
          self.orderId = iprot.readI64();
94 ashish 8587 
        else:
8588 
          iprot.skip(ftype)
8589 
      elif fid == 2:
8590 
        if ftype == TType.I64:
3064 chandransh 8591 
          self.customerId = iprot.readI64();
94 ashish 8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      else:
8595 
        iprot.skip(ftype)
8596 
      iprot.readFieldEnd()
8597 
    iprot.readStructEnd()
8598 
 
8599 
  def write(self, oprot):
8600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8602 
      return
3064 chandransh 8603 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8604 
    if self.orderId is not None:
3064 chandransh 8605 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8606 
      oprot.writeI64(self.orderId)
8607 
      oprot.writeFieldEnd()
3431 rajveer 8608 
    if self.customerId is not None:
3064 chandransh 8609 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8610 
      oprot.writeI64(self.customerId)
94 ashish 8611 
      oprot.writeFieldEnd()
8612 
    oprot.writeFieldStop()
8613 
    oprot.writeStructEnd()
8614 
 
3431 rajveer 8615 
  def validate(self):
8616 
    return
8617 
 
8618 
 
94 ashish 8619 
  def __repr__(self):
8620 
    L = ['%s=%r' % (key, value)
8621 
      for key, value in self.__dict__.iteritems()]
8622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8623 
 
8624 
  def __eq__(self, other):
8625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8626 
 
8627 
  def __ne__(self, other):
8628 
    return not (self == other)
8629 
 
3064 chandransh 8630 
class getOrderForCustomer_result:
94 ashish 8631 
  """
8632 
  Attributes:
8633 
   - success
8634 
   - ex
8635 
  """
8636 
 
8637 
  thrift_spec = (
3064 chandransh 8638 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8640 
  )
8641 
 
8642 
  def __init__(self, success=None, ex=None,):
8643 
    self.success = success
8644 
    self.ex = ex
8645 
 
8646 
  def read(self, iprot):
8647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8649 
      return
8650 
    iprot.readStructBegin()
8651 
    while True:
8652 
      (fname, ftype, fid) = iprot.readFieldBegin()
8653 
      if ftype == TType.STOP:
8654 
        break
8655 
      if fid == 0:
3064 chandransh 8656 
        if ftype == TType.STRUCT:
8657 
          self.success = Order()
8658 
          self.success.read(iprot)
94 ashish 8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      elif fid == 1:
8662 
        if ftype == TType.STRUCT:
8663 
          self.ex = TransactionServiceException()
8664 
          self.ex.read(iprot)
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      else:
8668 
        iprot.skip(ftype)
8669 
      iprot.readFieldEnd()
8670 
    iprot.readStructEnd()
8671 
 
8672 
  def write(self, oprot):
8673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8675 
      return
3064 chandransh 8676 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8677 
    if self.success is not None:
3064 chandransh 8678 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8679 
      self.success.write(oprot)
94 ashish 8680 
      oprot.writeFieldEnd()
3431 rajveer 8681 
    if self.ex is not None:
94 ashish 8682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8683 
      self.ex.write(oprot)
8684 
      oprot.writeFieldEnd()
8685 
    oprot.writeFieldStop()
8686 
    oprot.writeStructEnd()
8687 
 
3431 rajveer 8688 
  def validate(self):
8689 
    return
8690 
 
8691 
 
94 ashish 8692 
  def __repr__(self):
8693 
    L = ['%s=%r' % (key, value)
8694 
      for key, value in self.__dict__.iteritems()]
8695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8696 
 
8697 
  def __eq__(self, other):
8698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8699 
 
8700 
  def __ne__(self, other):
8701 
    return not (self == other)
8702 
 
3064 chandransh 8703 
class getAlerts_args:
94 ashish 8704 
  """
8705 
  Attributes:
4394 rajveer 8706 
   - type
4444 rajveer 8707 
   - warehouseId
4394 rajveer 8708 
   - status
8709 
   - timestamp
94 ashish 8710 
  """
8711 
 
8712 
  thrift_spec = (
8713 
    None, # 0
4394 rajveer 8714 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8715 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8716 
    (3, TType.I64, 'status', None, None, ), # 3
8717 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8718 
  )
8719 
 
4444 rajveer 8720 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8721 
    self.type = type
4444 rajveer 8722 
    self.warehouseId = warehouseId
4394 rajveer 8723 
    self.status = status
8724 
    self.timestamp = timestamp
94 ashish 8725 
 
8726 
  def read(self, iprot):
8727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8729 
      return
8730 
    iprot.readStructBegin()
8731 
    while True:
8732 
      (fname, ftype, fid) = iprot.readFieldBegin()
8733 
      if ftype == TType.STOP:
8734 
        break
8735 
      if fid == 1:
3064 chandransh 8736 
        if ftype == TType.I64:
4394 rajveer 8737 
          self.type = iprot.readI64();
94 ashish 8738 
        else:
8739 
          iprot.skip(ftype)
3064 chandransh 8740 
      elif fid == 2:
4394 rajveer 8741 
        if ftype == TType.I64:
4444 rajveer 8742 
          self.warehouseId = iprot.readI64();
3064 chandransh 8743 
        else:
8744 
          iprot.skip(ftype)
4394 rajveer 8745 
      elif fid == 3:
8746 
        if ftype == TType.I64:
4444 rajveer 8747 
          self.status = iprot.readI64();
8748 
        else:
8749 
          iprot.skip(ftype)
8750 
      elif fid == 4:
8751 
        if ftype == TType.I64:
4394 rajveer 8752 
          self.timestamp = iprot.readI64();
8753 
        else:
8754 
          iprot.skip(ftype)
94 ashish 8755 
      else:
8756 
        iprot.skip(ftype)
8757 
      iprot.readFieldEnd()
8758 
    iprot.readStructEnd()
8759 
 
8760 
  def write(self, oprot):
8761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8763 
      return
3064 chandransh 8764 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8765 
    if self.type is not None:
8766 
      oprot.writeFieldBegin('type', TType.I64, 1)
8767 
      oprot.writeI64(self.type)
94 ashish 8768 
      oprot.writeFieldEnd()
4444 rajveer 8769 
    if self.warehouseId is not None:
8770 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8771 
      oprot.writeI64(self.warehouseId)
8772 
      oprot.writeFieldEnd()
4394 rajveer 8773 
    if self.status is not None:
4444 rajveer 8774 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8775 
      oprot.writeI64(self.status)
3064 chandransh 8776 
      oprot.writeFieldEnd()
4394 rajveer 8777 
    if self.timestamp is not None:
4444 rajveer 8778 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8779 
      oprot.writeI64(self.timestamp)
8780 
      oprot.writeFieldEnd()
94 ashish 8781 
    oprot.writeFieldStop()
8782 
    oprot.writeStructEnd()
8783 
 
3431 rajveer 8784 
  def validate(self):
8785 
    return
8786 
 
8787 
 
94 ashish 8788 
  def __repr__(self):
8789 
    L = ['%s=%r' % (key, value)
8790 
      for key, value in self.__dict__.iteritems()]
8791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8792 
 
8793 
  def __eq__(self, other):
8794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8795 
 
8796 
  def __ne__(self, other):
8797 
    return not (self == other)
8798 
 
3064 chandransh 8799 
class getAlerts_result:
94 ashish 8800 
  """
8801 
  Attributes:
8802 
   - success
8803 
  """
8804 
 
8805 
  thrift_spec = (
3064 chandransh 8806 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8807 
  )
8808 
 
3064 chandransh 8809 
  def __init__(self, success=None,):
94 ashish 8810 
    self.success = success
8811 
 
8812 
  def read(self, iprot):
8813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8815 
      return
8816 
    iprot.readStructBegin()
8817 
    while True:
8818 
      (fname, ftype, fid) = iprot.readFieldBegin()
8819 
      if ftype == TType.STOP:
8820 
        break
8821 
      if fid == 0:
3064 chandransh 8822 
        if ftype == TType.LIST:
8823 
          self.success = []
4133 chandransh 8824 
          (_etype115, _size112) = iprot.readListBegin()
8825 
          for _i116 in xrange(_size112):
8826 
            _elem117 = Alert()
8827 
            _elem117.read(iprot)
8828 
            self.success.append(_elem117)
3064 chandransh 8829 
          iprot.readListEnd()
94 ashish 8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      else:
8833 
        iprot.skip(ftype)
8834 
      iprot.readFieldEnd()
8835 
    iprot.readStructEnd()
8836 
 
8837 
  def write(self, oprot):
8838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8840 
      return
3064 chandransh 8841 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8842 
    if self.success is not None:
3064 chandransh 8843 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8844 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8845 
      for iter118 in self.success:
8846 
        iter118.write(oprot)
3064 chandransh 8847 
      oprot.writeListEnd()
94 ashish 8848 
      oprot.writeFieldEnd()
8849 
    oprot.writeFieldStop()
8850 
    oprot.writeStructEnd()
8851 
 
3431 rajveer 8852 
  def validate(self):
8853 
    return
8854 
 
8855 
 
94 ashish 8856 
  def __repr__(self):
8857 
    L = ['%s=%r' % (key, value)
8858 
      for key, value in self.__dict__.iteritems()]
8859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8860 
 
8861 
  def __eq__(self, other):
8862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8863 
 
8864 
  def __ne__(self, other):
8865 
    return not (self == other)
8866 
 
4394 rajveer 8867 
class addAlert_args:
94 ashish 8868 
  """
8869 
  Attributes:
3064 chandransh 8870 
   - type
4444 rajveer 8871 
   - warehouseId
4394 rajveer 8872 
   - description
94 ashish 8873 
  """
8874 
 
8875 
  thrift_spec = (
8876 
    None, # 0
4394 rajveer 8877 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8878 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8879 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8880 
  )
8881 
 
4444 rajveer 8882 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8883 
    self.type = type
4444 rajveer 8884 
    self.warehouseId = warehouseId
4394 rajveer 8885 
    self.description = description
94 ashish 8886 
 
8887 
  def read(self, iprot):
8888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8890 
      return
8891 
    iprot.readStructBegin()
8892 
    while True:
8893 
      (fname, ftype, fid) = iprot.readFieldBegin()
8894 
      if ftype == TType.STOP:
8895 
        break
8896 
      if fid == 1:
8897 
        if ftype == TType.I64:
4394 rajveer 8898 
          self.type = iprot.readI64();
94 ashish 8899 
        else:
8900 
          iprot.skip(ftype)
3064 chandransh 8901 
      elif fid == 2:
4444 rajveer 8902 
        if ftype == TType.I64:
8903 
          self.warehouseId = iprot.readI64();
8904 
        else:
8905 
          iprot.skip(ftype)
8906 
      elif fid == 3:
3064 chandransh 8907 
        if ftype == TType.STRING:
4394 rajveer 8908 
          self.description = iprot.readString();
3064 chandransh 8909 
        else:
8910 
          iprot.skip(ftype)
94 ashish 8911 
      else:
8912 
        iprot.skip(ftype)
8913 
      iprot.readFieldEnd()
8914 
    iprot.readStructEnd()
8915 
 
8916 
  def write(self, oprot):
8917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8919 
      return
4394 rajveer 8920 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8921 
    if self.type is not None:
4394 rajveer 8922 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8923 
      oprot.writeI64(self.type)
8924 
      oprot.writeFieldEnd()
4444 rajveer 8925 
    if self.warehouseId is not None:
8926 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8927 
      oprot.writeI64(self.warehouseId)
8928 
      oprot.writeFieldEnd()
4394 rajveer 8929 
    if self.description is not None:
4444 rajveer 8930 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8931 
      oprot.writeString(self.description)
3064 chandransh 8932 
      oprot.writeFieldEnd()
94 ashish 8933 
    oprot.writeFieldStop()
8934 
    oprot.writeStructEnd()
8935 
 
3431 rajveer 8936 
  def validate(self):
8937 
    return
8938 
 
8939 
 
94 ashish 8940 
  def __repr__(self):
8941 
    L = ['%s=%r' % (key, value)
8942 
      for key, value in self.__dict__.iteritems()]
8943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8944 
 
8945 
  def __eq__(self, other):
8946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8947 
 
8948 
  def __ne__(self, other):
8949 
    return not (self == other)
8950 
 
4394 rajveer 8951 
class addAlert_result:
3064 chandransh 8952 
 
8953 
  thrift_spec = (
8954 
  )
8955 
 
8956 
  def read(self, iprot):
8957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8959 
      return
8960 
    iprot.readStructBegin()
8961 
    while True:
8962 
      (fname, ftype, fid) = iprot.readFieldBegin()
8963 
      if ftype == TType.STOP:
8964 
        break
8965 
      else:
8966 
        iprot.skip(ftype)
8967 
      iprot.readFieldEnd()
8968 
    iprot.readStructEnd()
8969 
 
8970 
  def write(self, oprot):
8971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8973 
      return
4394 rajveer 8974 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
3431 rajveer 8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
3064 chandransh 8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
4444 rajveer 8993 
class markAlertsAsSeen_args:
8994 
  """
8995 
  Attributes:
8996 
   - warehouseId
8997 
  """
8998 
 
8999 
  thrift_spec = (
9000 
    None, # 0
9001 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9002 
  )
9003 
 
9004 
  def __init__(self, warehouseId=None,):
9005 
    self.warehouseId = warehouseId
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      if fid == 1:
9017 
        if ftype == TType.I64:
9018 
          self.warehouseId = iprot.readI64();
9019 
        else:
9020 
          iprot.skip(ftype)
9021 
      else:
9022 
        iprot.skip(ftype)
9023 
      iprot.readFieldEnd()
9024 
    iprot.readStructEnd()
9025 
 
9026 
  def write(self, oprot):
9027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9029 
      return
9030 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9031 
    if self.warehouseId is not None:
9032 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9033 
      oprot.writeI64(self.warehouseId)
9034 
      oprot.writeFieldEnd()
9035 
    oprot.writeFieldStop()
9036 
    oprot.writeStructEnd()
9037 
 
9038 
  def validate(self):
9039 
    return
9040 
 
9041 
 
9042 
  def __repr__(self):
9043 
    L = ['%s=%r' % (key, value)
9044 
      for key, value in self.__dict__.iteritems()]
9045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9046 
 
9047 
  def __eq__(self, other):
9048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9049 
 
9050 
  def __ne__(self, other):
9051 
    return not (self == other)
9052 
 
9053 
class markAlertsAsSeen_result:
9054 
 
9055 
  thrift_spec = (
9056 
  )
9057 
 
9058 
  def read(self, iprot):
9059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9061 
      return
9062 
    iprot.readStructBegin()
9063 
    while True:
9064 
      (fname, ftype, fid) = iprot.readFieldBegin()
9065 
      if ftype == TType.STOP:
9066 
        break
9067 
      else:
9068 
        iprot.skip(ftype)
9069 
      iprot.readFieldEnd()
9070 
    iprot.readStructEnd()
9071 
 
9072 
  def write(self, oprot):
9073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9075 
      return
9076 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9077 
    oprot.writeFieldStop()
9078 
    oprot.writeStructEnd()
9079 
 
9080 
  def validate(self):
9081 
    return
9082 
 
9083 
 
9084 
  def __repr__(self):
9085 
    L = ['%s=%r' % (key, value)
9086 
      for key, value in self.__dict__.iteritems()]
9087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9088 
 
9089 
  def __eq__(self, other):
9090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9091 
 
9092 
  def __ne__(self, other):
9093 
    return not (self == other)
9094 
 
3064 chandransh 9095 
class getValidOrderCount_args:
9096 
 
9097 
  thrift_spec = (
9098 
  )
9099 
 
9100 
  def read(self, iprot):
9101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9103 
      return
9104 
    iprot.readStructBegin()
9105 
    while True:
9106 
      (fname, ftype, fid) = iprot.readFieldBegin()
9107 
      if ftype == TType.STOP:
9108 
        break
9109 
      else:
9110 
        iprot.skip(ftype)
9111 
      iprot.readFieldEnd()
9112 
    iprot.readStructEnd()
9113 
 
9114 
  def write(self, oprot):
9115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9117 
      return
9118 
    oprot.writeStructBegin('getValidOrderCount_args')
9119 
    oprot.writeFieldStop()
9120 
    oprot.writeStructEnd()
9121 
 
3431 rajveer 9122 
  def validate(self):
9123 
    return
9124 
 
9125 
 
3064 chandransh 9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
9137 
class getValidOrderCount_result:
94 ashish 9138 
  """
9139 
  Attributes:
9140 
   - success
9141 
  """
9142 
 
9143 
  thrift_spec = (
3064 chandransh 9144 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9145 
  )
9146 
 
3064 chandransh 9147 
  def __init__(self, success=None,):
94 ashish 9148 
    self.success = success
9149 
 
9150 
  def read(self, iprot):
9151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9153 
      return
9154 
    iprot.readStructBegin()
9155 
    while True:
9156 
      (fname, ftype, fid) = iprot.readFieldBegin()
9157 
      if ftype == TType.STOP:
9158 
        break
9159 
      if fid == 0:
3064 chandransh 9160 
        if ftype == TType.I64:
9161 
          self.success = iprot.readI64();
94 ashish 9162 
        else:
9163 
          iprot.skip(ftype)
9164 
      else:
9165 
        iprot.skip(ftype)
9166 
      iprot.readFieldEnd()
9167 
    iprot.readStructEnd()
9168 
 
9169 
  def write(self, oprot):
9170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9172 
      return
3064 chandransh 9173 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9174 
    if self.success is not None:
3064 chandransh 9175 
      oprot.writeFieldBegin('success', TType.I64, 0)
9176 
      oprot.writeI64(self.success)
94 ashish 9177 
      oprot.writeFieldEnd()
9178 
    oprot.writeFieldStop()
9179 
    oprot.writeStructEnd()
9180 
 
3431 rajveer 9181 
  def validate(self):
9182 
    return
9183 
 
9184 
 
94 ashish 9185 
  def __repr__(self):
9186 
    L = ['%s=%r' % (key, value)
9187 
      for key, value in self.__dict__.iteritems()]
9188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9189 
 
9190 
  def __eq__(self, other):
9191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9192 
 
9193 
  def __ne__(self, other):
9194 
    return not (self == other)
9195 
 
3064 chandransh 9196 
class getNoOfCustomersWithSuccessfulTransaction_args:
9197 
 
9198 
  thrift_spec = (
9199 
  )
9200 
 
9201 
  def read(self, iprot):
9202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9204 
      return
9205 
    iprot.readStructBegin()
9206 
    while True:
9207 
      (fname, ftype, fid) = iprot.readFieldBegin()
9208 
      if ftype == TType.STOP:
9209 
        break
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9220 
    oprot.writeFieldStop()
9221 
    oprot.writeStructEnd()
9222 
 
3431 rajveer 9223 
  def validate(self):
9224 
    return
9225 
 
9226 
 
3064 chandransh 9227 
  def __repr__(self):
9228 
    L = ['%s=%r' % (key, value)
9229 
      for key, value in self.__dict__.iteritems()]
9230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9231 
 
9232 
  def __eq__(self, other):
9233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9234 
 
9235 
  def __ne__(self, other):
9236 
    return not (self == other)
9237 
 
9238 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9239 
  """
9240 
  Attributes:
3064 chandransh 9241 
   - success
94 ashish 9242 
  """
9243 
 
9244 
  thrift_spec = (
3064 chandransh 9245 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9246 
  )
9247 
 
3064 chandransh 9248 
  def __init__(self, success=None,):
9249 
    self.success = success
94 ashish 9250 
 
9251 
  def read(self, iprot):
9252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9254 
      return
9255 
    iprot.readStructBegin()
9256 
    while True:
9257 
      (fname, ftype, fid) = iprot.readFieldBegin()
9258 
      if ftype == TType.STOP:
9259 
        break
3064 chandransh 9260 
      if fid == 0:
94 ashish 9261 
        if ftype == TType.I64:
3064 chandransh 9262 
          self.success = iprot.readI64();
94 ashish 9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      else:
9266 
        iprot.skip(ftype)
9267 
      iprot.readFieldEnd()
9268 
    iprot.readStructEnd()
9269 
 
9270 
  def write(self, oprot):
9271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9273 
      return
3064 chandransh 9274 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9275 
    if self.success is not None:
3064 chandransh 9276 
      oprot.writeFieldBegin('success', TType.I64, 0)
9277 
      oprot.writeI64(self.success)
94 ashish 9278 
      oprot.writeFieldEnd()
9279 
    oprot.writeFieldStop()
9280 
    oprot.writeStructEnd()
9281 
 
3431 rajveer 9282 
  def validate(self):
9283 
    return
9284 
 
9285 
 
94 ashish 9286 
  def __repr__(self):
9287 
    L = ['%s=%r' % (key, value)
9288 
      for key, value in self.__dict__.iteritems()]
9289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9290 
 
9291 
  def __eq__(self, other):
9292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9293 
 
9294 
  def __ne__(self, other):
9295 
    return not (self == other)
9296 
 
3064 chandransh 9297 
class getValidOrdersAmountRange_args:
9298 
 
9299 
  thrift_spec = (
9300 
  )
9301 
 
9302 
  def read(self, iprot):
9303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9305 
      return
9306 
    iprot.readStructBegin()
9307 
    while True:
9308 
      (fname, ftype, fid) = iprot.readFieldBegin()
9309 
      if ftype == TType.STOP:
9310 
        break
9311 
      else:
9312 
        iprot.skip(ftype)
9313 
      iprot.readFieldEnd()
9314 
    iprot.readStructEnd()
9315 
 
9316 
  def write(self, oprot):
9317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9319 
      return
9320 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9321 
    oprot.writeFieldStop()
9322 
    oprot.writeStructEnd()
9323 
 
3431 rajveer 9324 
  def validate(self):
9325 
    return
9326 
 
9327 
 
3064 chandransh 9328 
  def __repr__(self):
9329 
    L = ['%s=%r' % (key, value)
9330 
      for key, value in self.__dict__.iteritems()]
9331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9332 
 
9333 
  def __eq__(self, other):
9334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9335 
 
9336 
  def __ne__(self, other):
9337 
    return not (self == other)
9338 
 
9339 
class getValidOrdersAmountRange_result:
94 ashish 9340 
  """
9341 
  Attributes:
9342 
   - success
9343 
  """
9344 
 
9345 
  thrift_spec = (
3064 chandransh 9346 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9347 
  )
9348 
 
3064 chandransh 9349 
  def __init__(self, success=None,):
94 ashish 9350 
    self.success = success
9351 
 
9352 
  def read(self, iprot):
9353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9355 
      return
9356 
    iprot.readStructBegin()
9357 
    while True:
9358 
      (fname, ftype, fid) = iprot.readFieldBegin()
9359 
      if ftype == TType.STOP:
9360 
        break
9361 
      if fid == 0:
483 rajveer 9362 
        if ftype == TType.LIST:
9363 
          self.success = []
4133 chandransh 9364 
          (_etype122, _size119) = iprot.readListBegin()
9365 
          for _i123 in xrange(_size119):
9366 
            _elem124 = iprot.readDouble();
9367 
            self.success.append(_elem124)
483 rajveer 9368 
          iprot.readListEnd()
94 ashish 9369 
        else:
9370 
          iprot.skip(ftype)
9371 
      else:
9372 
        iprot.skip(ftype)
9373 
      iprot.readFieldEnd()
9374 
    iprot.readStructEnd()
9375 
 
9376 
  def write(self, oprot):
9377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9379 
      return
3064 chandransh 9380 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9381 
    if self.success is not None:
483 rajveer 9382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9383 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9384 
      for iter125 in self.success:
9385 
        oprot.writeDouble(iter125)
483 rajveer 9386 
      oprot.writeListEnd()
94 ashish 9387 
      oprot.writeFieldEnd()
9388 
    oprot.writeFieldStop()
9389 
    oprot.writeStructEnd()
9390 
 
3431 rajveer 9391 
  def validate(self):
9392 
    return
9393 
 
9394 
 
94 ashish 9395 
  def __repr__(self):
9396 
    L = ['%s=%r' % (key, value)
9397 
      for key, value in self.__dict__.iteritems()]
9398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9399 
 
9400 
  def __eq__(self, other):
9401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9402 
 
9403 
  def __ne__(self, other):
9404 
    return not (self == other)
9405 
 
3064 chandransh 9406 
class getValidOrders_args:
1528 ankur.sing 9407 
  """
9408 
  Attributes:
3064 chandransh 9409 
   - limit
1528 ankur.sing 9410 
  """
9411 
 
9412 
  thrift_spec = (
9413 
    None, # 0
3064 chandransh 9414 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9415 
  )
9416 
 
3064 chandransh 9417 
  def __init__(self, limit=None,):
9418 
    self.limit = limit
1528 ankur.sing 9419 
 
9420 
  def read(self, iprot):
9421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9423 
      return
9424 
    iprot.readStructBegin()
9425 
    while True:
9426 
      (fname, ftype, fid) = iprot.readFieldBegin()
9427 
      if ftype == TType.STOP:
9428 
        break
9429 
      if fid == 1:
9430 
        if ftype == TType.I64:
3064 chandransh 9431 
          self.limit = iprot.readI64();
1528 ankur.sing 9432 
        else:
9433 
          iprot.skip(ftype)
9434 
      else:
9435 
        iprot.skip(ftype)
9436 
      iprot.readFieldEnd()
9437 
    iprot.readStructEnd()
9438 
 
9439 
  def write(self, oprot):
9440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9442 
      return
3064 chandransh 9443 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9444 
    if self.limit is not None:
3064 chandransh 9445 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9446 
      oprot.writeI64(self.limit)
1528 ankur.sing 9447 
      oprot.writeFieldEnd()
9448 
    oprot.writeFieldStop()
9449 
    oprot.writeStructEnd()
9450 
 
3431 rajveer 9451 
  def validate(self):
9452 
    return
9453 
 
9454 
 
1528 ankur.sing 9455 
  def __repr__(self):
9456 
    L = ['%s=%r' % (key, value)
9457 
      for key, value in self.__dict__.iteritems()]
9458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9459 
 
9460 
  def __eq__(self, other):
9461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9462 
 
9463 
  def __ne__(self, other):
9464 
    return not (self == other)
9465 
 
3064 chandransh 9466 
class getValidOrders_result:
1528 ankur.sing 9467 
  """
9468 
  Attributes:
9469 
   - success
9470 
  """
9471 
 
9472 
  thrift_spec = (
3064 chandransh 9473 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9474 
  )
9475 
 
3064 chandransh 9476 
  def __init__(self, success=None,):
1528 ankur.sing 9477 
    self.success = success
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 0:
3064 chandransh 9489 
        if ftype == TType.LIST:
9490 
          self.success = []
4133 chandransh 9491 
          (_etype129, _size126) = iprot.readListBegin()
9492 
          for _i130 in xrange(_size126):
9493 
            _elem131 = Order()
9494 
            _elem131.read(iprot)
9495 
            self.success.append(_elem131)
3064 chandransh 9496 
          iprot.readListEnd()
1528 ankur.sing 9497 
        else:
9498 
          iprot.skip(ftype)
9499 
      else:
9500 
        iprot.skip(ftype)
9501 
      iprot.readFieldEnd()
9502 
    iprot.readStructEnd()
9503 
 
9504 
  def write(self, oprot):
9505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9507 
      return
3064 chandransh 9508 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9509 
    if self.success is not None:
3064 chandransh 9510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9512 
      for iter132 in self.success:
9513 
        iter132.write(oprot)
3064 chandransh 9514 
      oprot.writeListEnd()
1528 ankur.sing 9515 
      oprot.writeFieldEnd()
9516 
    oprot.writeFieldStop()
9517 
    oprot.writeStructEnd()
9518 
 
3431 rajveer 9519 
  def validate(self):
9520 
    return
9521 
 
9522 
 
1528 ankur.sing 9523 
  def __repr__(self):
9524 
    L = ['%s=%r' % (key, value)
9525 
      for key, value in self.__dict__.iteritems()]
9526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9527 
 
9528 
  def __eq__(self, other):
9529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9530 
 
9531 
  def __ne__(self, other):
9532 
    return not (self == other)
9533 
 
1220 chandransh 9534 
class batchOrders_args:
9535 
  """
9536 
  Attributes:
9537 
   - warehouseId
9538 
  """
9539 
 
9540 
  thrift_spec = (
9541 
    None, # 0
9542 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9543 
  )
9544 
 
9545 
  def __init__(self, warehouseId=None,):
9546 
    self.warehouseId = warehouseId
9547 
 
9548 
  def read(self, iprot):
9549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9551 
      return
9552 
    iprot.readStructBegin()
9553 
    while True:
9554 
      (fname, ftype, fid) = iprot.readFieldBegin()
9555 
      if ftype == TType.STOP:
9556 
        break
9557 
      if fid == 1:
9558 
        if ftype == TType.I64:
9559 
          self.warehouseId = iprot.readI64();
9560 
        else:
9561 
          iprot.skip(ftype)
9562 
      else:
9563 
        iprot.skip(ftype)
9564 
      iprot.readFieldEnd()
9565 
    iprot.readStructEnd()
9566 
 
9567 
  def write(self, oprot):
9568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9570 
      return
9571 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9572 
    if self.warehouseId is not None:
1220 chandransh 9573 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9574 
      oprot.writeI64(self.warehouseId)
9575 
      oprot.writeFieldEnd()
9576 
    oprot.writeFieldStop()
9577 
    oprot.writeStructEnd()
9578 
 
3431 rajveer 9579 
  def validate(self):
9580 
    return
9581 
 
9582 
 
1220 chandransh 9583 
  def __repr__(self):
9584 
    L = ['%s=%r' % (key, value)
9585 
      for key, value in self.__dict__.iteritems()]
9586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9587 
 
9588 
  def __eq__(self, other):
9589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9590 
 
9591 
  def __ne__(self, other):
9592 
    return not (self == other)
9593 
 
9594 
class batchOrders_result:
9595 
  """
9596 
  Attributes:
9597 
   - success
9598 
   - ex
9599 
  """
9600 
 
9601 
  thrift_spec = (
9602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9604 
  )
9605 
 
9606 
  def __init__(self, success=None, ex=None,):
9607 
    self.success = success
9608 
    self.ex = ex
9609 
 
9610 
  def read(self, iprot):
9611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9613 
      return
9614 
    iprot.readStructBegin()
9615 
    while True:
9616 
      (fname, ftype, fid) = iprot.readFieldBegin()
9617 
      if ftype == TType.STOP:
9618 
        break
9619 
      if fid == 0:
9620 
        if ftype == TType.LIST:
9621 
          self.success = []
4133 chandransh 9622 
          (_etype136, _size133) = iprot.readListBegin()
9623 
          for _i137 in xrange(_size133):
9624 
            _elem138 = Order()
9625 
            _elem138.read(iprot)
9626 
            self.success.append(_elem138)
1220 chandransh 9627 
          iprot.readListEnd()
9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      elif fid == 1:
9631 
        if ftype == TType.STRUCT:
9632 
          self.ex = TransactionServiceException()
9633 
          self.ex.read(iprot)
9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      else:
9637 
        iprot.skip(ftype)
9638 
      iprot.readFieldEnd()
9639 
    iprot.readStructEnd()
9640 
 
9641 
  def write(self, oprot):
9642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9644 
      return
9645 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9646 
    if self.success is not None:
1220 chandransh 9647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9649 
      for iter139 in self.success:
9650 
        iter139.write(oprot)
1220 chandransh 9651 
      oprot.writeListEnd()
9652 
      oprot.writeFieldEnd()
3431 rajveer 9653 
    if self.ex is not None:
1220 chandransh 9654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9655 
      self.ex.write(oprot)
9656 
      oprot.writeFieldEnd()
9657 
    oprot.writeFieldStop()
9658 
    oprot.writeStructEnd()
9659 
 
3431 rajveer 9660 
  def validate(self):
9661 
    return
9662 
 
9663 
 
1220 chandransh 9664 
  def __repr__(self):
9665 
    L = ['%s=%r' % (key, value)
9666 
      for key, value in self.__dict__.iteritems()]
9667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9668 
 
9669 
  def __eq__(self, other):
9670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9671 
 
9672 
  def __ne__(self, other):
9673 
    return not (self == other)
9674 
 
1208 chandransh 9675 
class markOrderAsOutOfStock_args:
9676 
  """
9677 
  Attributes:
9678 
   - orderId
9679 
  """
9680 
 
9681 
  thrift_spec = (
9682 
    None, # 0
9683 
    (1, TType.I64, 'orderId', None, None, ), # 1
9684 
  )
9685 
 
9686 
  def __init__(self, orderId=None,):
9687 
    self.orderId = orderId
9688 
 
9689 
  def read(self, iprot):
9690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9692 
      return
9693 
    iprot.readStructBegin()
9694 
    while True:
9695 
      (fname, ftype, fid) = iprot.readFieldBegin()
9696 
      if ftype == TType.STOP:
9697 
        break
9698 
      if fid == 1:
9699 
        if ftype == TType.I64:
9700 
          self.orderId = iprot.readI64();
9701 
        else:
9702 
          iprot.skip(ftype)
9703 
      else:
9704 
        iprot.skip(ftype)
9705 
      iprot.readFieldEnd()
9706 
    iprot.readStructEnd()
9707 
 
9708 
  def write(self, oprot):
9709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9711 
      return
9712 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9713 
    if self.orderId is not None:
1208 chandransh 9714 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9715 
      oprot.writeI64(self.orderId)
9716 
      oprot.writeFieldEnd()
9717 
    oprot.writeFieldStop()
9718 
    oprot.writeStructEnd()
9719 
 
3431 rajveer 9720 
  def validate(self):
9721 
    return
9722 
 
9723 
 
1208 chandransh 9724 
  def __repr__(self):
9725 
    L = ['%s=%r' % (key, value)
9726 
      for key, value in self.__dict__.iteritems()]
9727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9728 
 
9729 
  def __eq__(self, other):
9730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9731 
 
9732 
  def __ne__(self, other):
9733 
    return not (self == other)
9734 
 
9735 
class markOrderAsOutOfStock_result:
9736 
  """
9737 
  Attributes:
9738 
   - success
9739 
   - ex
9740 
  """
9741 
 
9742 
  thrift_spec = (
9743 
    (0, TType.BOOL, 'success', None, None, ), # 0
9744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9745 
  )
9746 
 
9747 
  def __init__(self, success=None, ex=None,):
9748 
    self.success = success
9749 
    self.ex = ex
9750 
 
9751 
  def read(self, iprot):
9752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9754 
      return
9755 
    iprot.readStructBegin()
9756 
    while True:
9757 
      (fname, ftype, fid) = iprot.readFieldBegin()
9758 
      if ftype == TType.STOP:
9759 
        break
9760 
      if fid == 0:
9761 
        if ftype == TType.BOOL:
9762 
          self.success = iprot.readBool();
9763 
        else:
9764 
          iprot.skip(ftype)
9765 
      elif fid == 1:
9766 
        if ftype == TType.STRUCT:
9767 
          self.ex = TransactionServiceException()
9768 
          self.ex.read(iprot)
9769 
        else:
9770 
          iprot.skip(ftype)
9771 
      else:
9772 
        iprot.skip(ftype)
9773 
      iprot.readFieldEnd()
9774 
    iprot.readStructEnd()
9775 
 
9776 
  def write(self, oprot):
9777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9779 
      return
9780 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9781 
    if self.success is not None:
1208 chandransh 9782 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9783 
      oprot.writeBool(self.success)
9784 
      oprot.writeFieldEnd()
3431 rajveer 9785 
    if self.ex is not None:
1208 chandransh 9786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9787 
      self.ex.write(oprot)
9788 
      oprot.writeFieldEnd()
9789 
    oprot.writeFieldStop()
9790 
    oprot.writeStructEnd()
9791 
 
3431 rajveer 9792 
  def validate(self):
9793 
    return
9794 
 
9795 
 
1208 chandransh 9796 
  def __repr__(self):
9797 
    L = ['%s=%r' % (key, value)
9798 
      for key, value in self.__dict__.iteritems()]
9799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9800 
 
9801 
  def __eq__(self, other):
9802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9803 
 
9804 
  def __ne__(self, other):
9805 
    return not (self == other)
9806 
 
3064 chandransh 9807 
class verifyOrder_args:
759 chandransh 9808 
  """
9809 
  Attributes:
3064 chandransh 9810 
   - orderId
759 chandransh 9811 
  """
9812 
 
9813 
  thrift_spec = (
9814 
    None, # 0
3064 chandransh 9815 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9816 
  )
9817 
 
3064 chandransh 9818 
  def __init__(self, orderId=None,):
9819 
    self.orderId = orderId
759 chandransh 9820 
 
9821 
  def read(self, iprot):
9822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9824 
      return
9825 
    iprot.readStructBegin()
9826 
    while True:
9827 
      (fname, ftype, fid) = iprot.readFieldBegin()
9828 
      if ftype == TType.STOP:
9829 
        break
9830 
      if fid == 1:
9831 
        if ftype == TType.I64:
3064 chandransh 9832 
          self.orderId = iprot.readI64();
759 chandransh 9833 
        else:
9834 
          iprot.skip(ftype)
9835 
      else:
9836 
        iprot.skip(ftype)
9837 
      iprot.readFieldEnd()
9838 
    iprot.readStructEnd()
9839 
 
9840 
  def write(self, oprot):
9841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9843 
      return
3064 chandransh 9844 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9845 
    if self.orderId is not None:
3064 chandransh 9846 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9847 
      oprot.writeI64(self.orderId)
759 chandransh 9848 
      oprot.writeFieldEnd()
9849 
    oprot.writeFieldStop()
9850 
    oprot.writeStructEnd()
9851 
 
3431 rajveer 9852 
  def validate(self):
9853 
    return
9854 
 
9855 
 
759 chandransh 9856 
  def __repr__(self):
9857 
    L = ['%s=%r' % (key, value)
9858 
      for key, value in self.__dict__.iteritems()]
9859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9860 
 
9861 
  def __eq__(self, other):
9862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9863 
 
9864 
  def __ne__(self, other):
9865 
    return not (self == other)
9866 
 
3064 chandransh 9867 
class verifyOrder_result:
759 chandransh 9868 
  """
9869 
  Attributes:
9870 
   - success
9871 
   - ex
9872 
  """
9873 
 
9874 
  thrift_spec = (
9875 
    (0, TType.BOOL, 'success', None, None, ), # 0
9876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9877 
  )
9878 
 
9879 
  def __init__(self, success=None, ex=None,):
9880 
    self.success = success
9881 
    self.ex = ex
9882 
 
9883 
  def read(self, iprot):
9884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9886 
      return
9887 
    iprot.readStructBegin()
9888 
    while True:
9889 
      (fname, ftype, fid) = iprot.readFieldBegin()
9890 
      if ftype == TType.STOP:
9891 
        break
9892 
      if fid == 0:
9893 
        if ftype == TType.BOOL:
9894 
          self.success = iprot.readBool();
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      elif fid == 1:
9898 
        if ftype == TType.STRUCT:
9899 
          self.ex = TransactionServiceException()
9900 
          self.ex.read(iprot)
9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
3064 chandransh 9912 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9913 
    if self.success is not None:
759 chandransh 9914 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9915 
      oprot.writeBool(self.success)
9916 
      oprot.writeFieldEnd()
3431 rajveer 9917 
    if self.ex is not None:
759 chandransh 9918 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9919 
      self.ex.write(oprot)
9920 
      oprot.writeFieldEnd()
9921 
    oprot.writeFieldStop()
9922 
    oprot.writeStructEnd()
9923 
 
3431 rajveer 9924 
  def validate(self):
9925 
    return
9926 
 
9927 
 
759 chandransh 9928 
  def __repr__(self):
9929 
    L = ['%s=%r' % (key, value)
9930 
      for key, value in self.__dict__.iteritems()]
9931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9932 
 
9933 
  def __eq__(self, other):
9934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9935 
 
9936 
  def __ne__(self, other):
9937 
    return not (self == other)
9938 
 
3064 chandransh 9939 
class acceptOrder_args:
1113 chandransh 9940 
  """
9941 
  Attributes:
3064 chandransh 9942 
   - orderId
1113 chandransh 9943 
  """
9944 
 
9945 
  thrift_spec = (
9946 
    None, # 0
3064 chandransh 9947 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9948 
  )
9949 
 
3064 chandransh 9950 
  def __init__(self, orderId=None,):
9951 
    self.orderId = orderId
1113 chandransh 9952 
 
9953 
  def read(self, iprot):
9954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9956 
      return
9957 
    iprot.readStructBegin()
9958 
    while True:
9959 
      (fname, ftype, fid) = iprot.readFieldBegin()
9960 
      if ftype == TType.STOP:
9961 
        break
9962 
      if fid == 1:
9963 
        if ftype == TType.I64:
3064 chandransh 9964 
          self.orderId = iprot.readI64();
1113 chandransh 9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      else:
9968 
        iprot.skip(ftype)
9969 
      iprot.readFieldEnd()
9970 
    iprot.readStructEnd()
9971 
 
9972 
  def write(self, oprot):
9973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9975 
      return
3064 chandransh 9976 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9977 
    if self.orderId is not None:
3064 chandransh 9978 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9979 
      oprot.writeI64(self.orderId)
1113 chandransh 9980 
      oprot.writeFieldEnd()
9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
3431 rajveer 9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
1113 chandransh 9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
3064 chandransh 9999 
class acceptOrder_result:
1113 chandransh 10000 
  """
10001 
  Attributes:
10002 
   - success
10003 
   - ex
10004 
  """
10005 
 
10006 
  thrift_spec = (
3064 chandransh 10007 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10009 
  )
10010 
 
10011 
  def __init__(self, success=None, ex=None,):
10012 
    self.success = success
10013 
    self.ex = ex
10014 
 
10015 
  def read(self, iprot):
10016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10018 
      return
10019 
    iprot.readStructBegin()
10020 
    while True:
10021 
      (fname, ftype, fid) = iprot.readFieldBegin()
10022 
      if ftype == TType.STOP:
10023 
        break
10024 
      if fid == 0:
3064 chandransh 10025 
        if ftype == TType.BOOL:
10026 
          self.success = iprot.readBool();
1113 chandransh 10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      elif fid == 1:
10030 
        if ftype == TType.STRUCT:
10031 
          self.ex = TransactionServiceException()
10032 
          self.ex.read(iprot)
10033 
        else:
10034 
          iprot.skip(ftype)
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
3064 chandransh 10044 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10045 
    if self.success is not None:
3064 chandransh 10046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10047 
      oprot.writeBool(self.success)
1113 chandransh 10048 
      oprot.writeFieldEnd()
3431 rajveer 10049 
    if self.ex is not None:
1113 chandransh 10050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10051 
      self.ex.write(oprot)
10052 
      oprot.writeFieldEnd()
10053 
    oprot.writeFieldStop()
10054 
    oprot.writeStructEnd()
10055 
 
3431 rajveer 10056 
  def validate(self):
10057 
    return
10058 
 
10059 
 
1113 chandransh 10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
3064 chandransh 10071 
class addBillingDetails_args:
1135 chandransh 10072 
  """
10073 
  Attributes:
3064 chandransh 10074 
   - orderId
10075 
   - invoice_number
4283 anupam.sin 10076 
   - imeiNumber
10077 
   - itemNumber
3064 chandransh 10078 
   - billed_by
4264 rajveer 10079 
   - jacketNumber
4283 anupam.sin 10080 
   - billingType
10081 
   - vendorId
1135 chandransh 10082 
  """
10083 
 
10084 
  thrift_spec = (
10085 
    None, # 0
3064 chandransh 10086 
    (1, TType.I64, 'orderId', None, None, ), # 1
10087 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 10088 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
10089 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10090 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10091 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10092 
    (7, TType.I64, 'billingType', None, None, ), # 7
10093 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10094 
  )
10095 
 
4283 anupam.sin 10096 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10097 
    self.orderId = orderId
10098 
    self.invoice_number = invoice_number
4283 anupam.sin 10099 
    self.imeiNumber = imeiNumber
10100 
    self.itemNumber = itemNumber
3064 chandransh 10101 
    self.billed_by = billed_by
4264 rajveer 10102 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10103 
    self.billingType = billingType
10104 
    self.vendorId = vendorId
1135 chandransh 10105 
 
10106 
  def read(self, iprot):
10107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10109 
      return
10110 
    iprot.readStructBegin()
10111 
    while True:
10112 
      (fname, ftype, fid) = iprot.readFieldBegin()
10113 
      if ftype == TType.STOP:
10114 
        break
10115 
      if fid == 1:
10116 
        if ftype == TType.I64:
3064 chandransh 10117 
          self.orderId = iprot.readI64();
1135 chandransh 10118 
        else:
10119 
          iprot.skip(ftype)
10120 
      elif fid == 2:
3064 chandransh 10121 
        if ftype == TType.STRING:
10122 
          self.invoice_number = iprot.readString();
1135 chandransh 10123 
        else:
10124 
          iprot.skip(ftype)
3064 chandransh 10125 
      elif fid == 3:
4264 rajveer 10126 
        if ftype == TType.I64:
3064 chandransh 10127 
          self.imeiNumber = iprot.readI64();
10128 
        else:
10129 
          iprot.skip(ftype)
10130 
      elif fid == 4:
10131 
        if ftype == TType.STRING:
10132 
          self.itemNumber = iprot.readString();
10133 
        else:
10134 
          iprot.skip(ftype)
10135 
      elif fid == 5:
10136 
        if ftype == TType.STRING:
4283 anupam.sin 10137 
          self.billed_by = iprot.readString();
3064 chandransh 10138 
        else:
10139 
          iprot.skip(ftype)
10140 
      elif fid == 6:
10141 
        if ftype == TType.I64:
4283 anupam.sin 10142 
          self.jacketNumber = iprot.readI64();
10143 
        else:
10144 
          iprot.skip(ftype)
10145 
      elif fid == 7:
10146 
        if ftype == TType.I64:
3064 chandransh 10147 
          self.billingType = iprot.readI64();
10148 
        else:
10149 
          iprot.skip(ftype)
4283 anupam.sin 10150 
      elif fid == 8:
10151 
        if ftype == TType.I64:
10152 
          self.vendorId = iprot.readI64();
10153 
        else:
10154 
          iprot.skip(ftype)
1246 chandransh 10155 
      else:
10156 
        iprot.skip(ftype)
10157 
      iprot.readFieldEnd()
10158 
    iprot.readStructEnd()
10159 
 
10160 
  def write(self, oprot):
10161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10163 
      return
4283 anupam.sin 10164 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10165 
    if self.orderId is not None:
3064 chandransh 10166 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10167 
      oprot.writeI64(self.orderId)
1246 chandransh 10168 
      oprot.writeFieldEnd()
4283 anupam.sin 10169 
    if self.invoice_number is not None:
10170 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10171 
      oprot.writeString(self.invoice_number)
1246 chandransh 10172 
      oprot.writeFieldEnd()
3431 rajveer 10173 
    if self.imeiNumber is not None:
3064 chandransh 10174 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
10175 
      oprot.writeI64(self.imeiNumber)
10176 
      oprot.writeFieldEnd()
3431 rajveer 10177 
    if self.itemNumber is not None:
3064 chandransh 10178 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10179 
      oprot.writeString(self.itemNumber)
10180 
      oprot.writeFieldEnd()
4283 anupam.sin 10181 
    if self.billed_by is not None:
10182 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10183 
      oprot.writeString(self.billed_by)
3064 chandransh 10184 
      oprot.writeFieldEnd()
4283 anupam.sin 10185 
    if self.jacketNumber is not None:
10186 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10187 
      oprot.writeI64(self.jacketNumber)
10188 
      oprot.writeFieldEnd()
3431 rajveer 10189 
    if self.billingType is not None:
4283 anupam.sin 10190 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10191 
      oprot.writeI64(self.billingType)
10192 
      oprot.writeFieldEnd()
4283 anupam.sin 10193 
    if self.vendorId is not None:
10194 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10195 
      oprot.writeI64(self.vendorId)
10196 
      oprot.writeFieldEnd()
1246 chandransh 10197 
    oprot.writeFieldStop()
10198 
    oprot.writeStructEnd()
10199 
 
3431 rajveer 10200 
  def validate(self):
10201 
    return
10202 
 
10203 
 
1246 chandransh 10204 
  def __repr__(self):
10205 
    L = ['%s=%r' % (key, value)
10206 
      for key, value in self.__dict__.iteritems()]
10207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10208 
 
10209 
  def __eq__(self, other):
10210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10211 
 
10212 
  def __ne__(self, other):
10213 
    return not (self == other)
10214 
 
4283 anupam.sin 10215 
class addBillingDetails_result:
1246 chandransh 10216 
  """
10217 
  Attributes:
3064 chandransh 10218 
   - success
1246 chandransh 10219 
   - ex
10220 
  """
10221 
 
10222 
  thrift_spec = (
3064 chandransh 10223 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10225 
  )
10226 
 
3064 chandransh 10227 
  def __init__(self, success=None, ex=None,):
10228 
    self.success = success
1246 chandransh 10229 
    self.ex = ex
10230 
 
10231 
  def read(self, iprot):
10232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10234 
      return
10235 
    iprot.readStructBegin()
10236 
    while True:
10237 
      (fname, ftype, fid) = iprot.readFieldBegin()
10238 
      if ftype == TType.STOP:
10239 
        break
3064 chandransh 10240 
      if fid == 0:
10241 
        if ftype == TType.BOOL:
10242 
          self.success = iprot.readBool();
10243 
        else:
10244 
          iprot.skip(ftype)
10245 
      elif fid == 1:
1246 chandransh 10246 
        if ftype == TType.STRUCT:
10247 
          self.ex = TransactionServiceException()
10248 
          self.ex.read(iprot)
10249 
        else:
10250 
          iprot.skip(ftype)
10251 
      else:
10252 
        iprot.skip(ftype)
10253 
      iprot.readFieldEnd()
10254 
    iprot.readStructEnd()
10255 
 
10256 
  def write(self, oprot):
10257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10259 
      return
4283 anupam.sin 10260 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10261 
    if self.success is not None:
3064 chandransh 10262 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10263 
      oprot.writeBool(self.success)
10264 
      oprot.writeFieldEnd()
3431 rajveer 10265 
    if self.ex is not None:
1246 chandransh 10266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10267 
      self.ex.write(oprot)
10268 
      oprot.writeFieldEnd()
10269 
    oprot.writeFieldStop()
10270 
    oprot.writeStructEnd()
10271 
 
3431 rajveer 10272 
  def validate(self):
10273 
    return
10274 
 
10275 
 
1246 chandransh 10276 
  def __repr__(self):
10277 
    L = ['%s=%r' % (key, value)
10278 
      for key, value in self.__dict__.iteritems()]
10279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10280 
 
10281 
  def __eq__(self, other):
10282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10283 
 
10284 
  def __ne__(self, other):
10285 
    return not (self == other)
10286 
 
4579 rajveer 10287 
class addInvoiceNumber_args:
10288 
  """
10289 
  Attributes:
10290 
   - orderId
10291 
   - invoiceNumber
10292 
  """
10293 
 
10294 
  thrift_spec = (
10295 
    None, # 0
10296 
    (1, TType.I64, 'orderId', None, None, ), # 1
10297 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10298 
  )
10299 
 
10300 
  def __init__(self, orderId=None, invoiceNumber=None,):
10301 
    self.orderId = orderId
10302 
    self.invoiceNumber = invoiceNumber
10303 
 
10304 
  def read(self, iprot):
10305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10307 
      return
10308 
    iprot.readStructBegin()
10309 
    while True:
10310 
      (fname, ftype, fid) = iprot.readFieldBegin()
10311 
      if ftype == TType.STOP:
10312 
        break
10313 
      if fid == 1:
10314 
        if ftype == TType.I64:
10315 
          self.orderId = iprot.readI64();
10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      elif fid == 2:
10319 
        if ftype == TType.STRING:
10320 
          self.invoiceNumber = iprot.readString();
10321 
        else:
10322 
          iprot.skip(ftype)
10323 
      else:
10324 
        iprot.skip(ftype)
10325 
      iprot.readFieldEnd()
10326 
    iprot.readStructEnd()
10327 
 
10328 
  def write(self, oprot):
10329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10331 
      return
10332 
    oprot.writeStructBegin('addInvoiceNumber_args')
10333 
    if self.orderId is not None:
10334 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10335 
      oprot.writeI64(self.orderId)
10336 
      oprot.writeFieldEnd()
10337 
    if self.invoiceNumber is not None:
10338 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10339 
      oprot.writeString(self.invoiceNumber)
10340 
      oprot.writeFieldEnd()
10341 
    oprot.writeFieldStop()
10342 
    oprot.writeStructEnd()
10343 
 
10344 
  def validate(self):
10345 
    return
10346 
 
10347 
 
10348 
  def __repr__(self):
10349 
    L = ['%s=%r' % (key, value)
10350 
      for key, value in self.__dict__.iteritems()]
10351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10352 
 
10353 
  def __eq__(self, other):
10354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10355 
 
10356 
  def __ne__(self, other):
10357 
    return not (self == other)
10358 
 
10359 
class addInvoiceNumber_result:
10360 
  """
10361 
  Attributes:
10362 
   - ex
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    None, # 0
10367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10368 
  )
10369 
 
10370 
  def __init__(self, ex=None,):
10371 
    self.ex = ex
10372 
 
10373 
  def read(self, iprot):
10374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10376 
      return
10377 
    iprot.readStructBegin()
10378 
    while True:
10379 
      (fname, ftype, fid) = iprot.readFieldBegin()
10380 
      if ftype == TType.STOP:
10381 
        break
10382 
      if fid == 1:
10383 
        if ftype == TType.STRUCT:
10384 
          self.ex = TransactionServiceException()
10385 
          self.ex.read(iprot)
10386 
        else:
10387 
          iprot.skip(ftype)
10388 
      else:
10389 
        iprot.skip(ftype)
10390 
      iprot.readFieldEnd()
10391 
    iprot.readStructEnd()
10392 
 
10393 
  def write(self, oprot):
10394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10396 
      return
10397 
    oprot.writeStructBegin('addInvoiceNumber_result')
10398 
    if self.ex is not None:
10399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10400 
      self.ex.write(oprot)
10401 
      oprot.writeFieldEnd()
10402 
    oprot.writeFieldStop()
10403 
    oprot.writeStructEnd()
10404 
 
10405 
  def validate(self):
10406 
    return
10407 
 
10408 
 
10409 
  def __repr__(self):
10410 
    L = ['%s=%r' % (key, value)
10411 
      for key, value in self.__dict__.iteritems()]
10412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10413 
 
10414 
  def __eq__(self, other):
10415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10416 
 
10417 
  def __ne__(self, other):
10418 
    return not (self == other)
10419 
 
3064 chandransh 10420 
class markOrdersAsManifested_args:
1408 ankur.sing 10421 
  """
10422 
  Attributes:
3064 chandransh 10423 
   - warehouseId
1408 ankur.sing 10424 
   - providerId
3064 chandransh 10425 
   - cod
1408 ankur.sing 10426 
  """
10427 
 
10428 
  thrift_spec = (
10429 
    None, # 0
3064 chandransh 10430 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10431 
    (2, TType.I64, 'providerId', None, None, ), # 2
10432 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10433 
  )
10434 
 
3064 chandransh 10435 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10436 
    self.warehouseId = warehouseId
1408 ankur.sing 10437 
    self.providerId = providerId
3064 chandransh 10438 
    self.cod = cod
1408 ankur.sing 10439 
 
10440 
  def read(self, iprot):
10441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10443 
      return
10444 
    iprot.readStructBegin()
10445 
    while True:
10446 
      (fname, ftype, fid) = iprot.readFieldBegin()
10447 
      if ftype == TType.STOP:
10448 
        break
10449 
      if fid == 1:
10450 
        if ftype == TType.I64:
3064 chandransh 10451 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10452 
        else:
10453 
          iprot.skip(ftype)
10454 
      elif fid == 2:
10455 
        if ftype == TType.I64:
3064 chandransh 10456 
          self.providerId = iprot.readI64();
1408 ankur.sing 10457 
        else:
10458 
          iprot.skip(ftype)
3064 chandransh 10459 
      elif fid == 3:
10460 
        if ftype == TType.BOOL:
10461 
          self.cod = iprot.readBool();
10462 
        else:
10463 
          iprot.skip(ftype)
1408 ankur.sing 10464 
      else:
10465 
        iprot.skip(ftype)
10466 
      iprot.readFieldEnd()
10467 
    iprot.readStructEnd()
10468 
 
10469 
  def write(self, oprot):
10470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10472 
      return
3064 chandransh 10473 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10474 
    if self.warehouseId is not None:
3064 chandransh 10475 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10476 
      oprot.writeI64(self.warehouseId)
10477 
      oprot.writeFieldEnd()
3431 rajveer 10478 
    if self.providerId is not None:
3064 chandransh 10479 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10480 
      oprot.writeI64(self.providerId)
10481 
      oprot.writeFieldEnd()
3431 rajveer 10482 
    if self.cod is not None:
3064 chandransh 10483 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10484 
      oprot.writeBool(self.cod)
1408 ankur.sing 10485 
      oprot.writeFieldEnd()
10486 
    oprot.writeFieldStop()
10487 
    oprot.writeStructEnd()
10488 
 
3431 rajveer 10489 
  def validate(self):
10490 
    return
10491 
 
10492 
 
1408 ankur.sing 10493 
  def __repr__(self):
10494 
    L = ['%s=%r' % (key, value)
10495 
      for key, value in self.__dict__.iteritems()]
10496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10497 
 
10498 
  def __eq__(self, other):
10499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10500 
 
10501 
  def __ne__(self, other):
10502 
    return not (self == other)
10503 
 
3064 chandransh 10504 
class markOrdersAsManifested_result:
1408 ankur.sing 10505 
  """
10506 
  Attributes:
10507 
   - success
3064 chandransh 10508 
   - ex
1408 ankur.sing 10509 
  """
10510 
 
10511 
  thrift_spec = (
3064 chandransh 10512 
    (0, TType.BOOL, 'success', None, None, ), # 0
10513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10514 
  )
10515 
 
3064 chandransh 10516 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10517 
    self.success = success
3064 chandransh 10518 
    self.ex = ex
1408 ankur.sing 10519 
 
10520 
  def read(self, iprot):
10521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10523 
      return
10524 
    iprot.readStructBegin()
10525 
    while True:
10526 
      (fname, ftype, fid) = iprot.readFieldBegin()
10527 
      if ftype == TType.STOP:
10528 
        break
10529 
      if fid == 0:
3064 chandransh 10530 
        if ftype == TType.BOOL:
10531 
          self.success = iprot.readBool();
1408 ankur.sing 10532 
        else:
10533 
          iprot.skip(ftype)
3064 chandransh 10534 
      elif fid == 1:
10535 
        if ftype == TType.STRUCT:
10536 
          self.ex = TransactionServiceException()
10537 
          self.ex.read(iprot)
10538 
        else:
10539 
          iprot.skip(ftype)
1408 ankur.sing 10540 
      else:
10541 
        iprot.skip(ftype)
10542 
      iprot.readFieldEnd()
10543 
    iprot.readStructEnd()
10544 
 
10545 
  def write(self, oprot):
10546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10548 
      return
3064 chandransh 10549 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10550 
    if self.success is not None:
3064 chandransh 10551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10552 
      oprot.writeBool(self.success)
1408 ankur.sing 10553 
      oprot.writeFieldEnd()
3431 rajveer 10554 
    if self.ex is not None:
3064 chandransh 10555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10556 
      self.ex.write(oprot)
10557 
      oprot.writeFieldEnd()
1408 ankur.sing 10558 
    oprot.writeFieldStop()
10559 
    oprot.writeStructEnd()
10560 
 
3431 rajveer 10561 
  def validate(self):
10562 
    return
10563 
 
10564 
 
1408 ankur.sing 10565 
  def __repr__(self):
10566 
    L = ['%s=%r' % (key, value)
10567 
      for key, value in self.__dict__.iteritems()]
10568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10569 
 
10570 
  def __eq__(self, other):
10571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10572 
 
10573 
  def __ne__(self, other):
10574 
    return not (self == other)
10575 
 
4410 rajveer 10576 
class markOrdersAsShippedFromWarehouse_args:
10577 
  """
10578 
  Attributes:
10579 
   - warehouseId
10580 
   - providerId
10581 
   - cod
10582 
  """
10583 
 
10584 
  thrift_spec = (
10585 
    None, # 0
10586 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10587 
    (2, TType.I64, 'providerId', None, None, ), # 2
10588 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10589 
  )
10590 
 
10591 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10592 
    self.warehouseId = warehouseId
10593 
    self.providerId = providerId
10594 
    self.cod = cod
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 1:
10606 
        if ftype == TType.I64:
10607 
          self.warehouseId = iprot.readI64();
10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      elif fid == 2:
10611 
        if ftype == TType.I64:
10612 
          self.providerId = iprot.readI64();
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      elif fid == 3:
10616 
        if ftype == TType.BOOL:
10617 
          self.cod = iprot.readBool();
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      else:
10621 
        iprot.skip(ftype)
10622 
      iprot.readFieldEnd()
10623 
    iprot.readStructEnd()
10624 
 
10625 
  def write(self, oprot):
10626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10628 
      return
10629 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10630 
    if self.warehouseId is not None:
10631 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10632 
      oprot.writeI64(self.warehouseId)
10633 
      oprot.writeFieldEnd()
10634 
    if self.providerId is not None:
10635 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10636 
      oprot.writeI64(self.providerId)
10637 
      oprot.writeFieldEnd()
10638 
    if self.cod is not None:
10639 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10640 
      oprot.writeBool(self.cod)
10641 
      oprot.writeFieldEnd()
10642 
    oprot.writeFieldStop()
10643 
    oprot.writeStructEnd()
10644 
 
10645 
  def validate(self):
10646 
    return
10647 
 
10648 
 
10649 
  def __repr__(self):
10650 
    L = ['%s=%r' % (key, value)
10651 
      for key, value in self.__dict__.iteritems()]
10652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10653 
 
10654 
  def __eq__(self, other):
10655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10656 
 
10657 
  def __ne__(self, other):
10658 
    return not (self == other)
10659 
 
10660 
class markOrdersAsShippedFromWarehouse_result:
10661 
  """
10662 
  Attributes:
10663 
   - success
10664 
   - ex
10665 
  """
10666 
 
10667 
  thrift_spec = (
10668 
    (0, TType.BOOL, 'success', None, None, ), # 0
10669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10670 
  )
10671 
 
10672 
  def __init__(self, success=None, ex=None,):
10673 
    self.success = success
10674 
    self.ex = ex
10675 
 
10676 
  def read(self, iprot):
10677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10679 
      return
10680 
    iprot.readStructBegin()
10681 
    while True:
10682 
      (fname, ftype, fid) = iprot.readFieldBegin()
10683 
      if ftype == TType.STOP:
10684 
        break
10685 
      if fid == 0:
10686 
        if ftype == TType.BOOL:
10687 
          self.success = iprot.readBool();
10688 
        else:
10689 
          iprot.skip(ftype)
10690 
      elif fid == 1:
10691 
        if ftype == TType.STRUCT:
10692 
          self.ex = TransactionServiceException()
10693 
          self.ex.read(iprot)
10694 
        else:
10695 
          iprot.skip(ftype)
10696 
      else:
10697 
        iprot.skip(ftype)
10698 
      iprot.readFieldEnd()
10699 
    iprot.readStructEnd()
10700 
 
10701 
  def write(self, oprot):
10702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10704 
      return
10705 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10706 
    if self.success is not None:
10707 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10708 
      oprot.writeBool(self.success)
10709 
      oprot.writeFieldEnd()
10710 
    if self.ex is not None:
10711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10712 
      self.ex.write(oprot)
10713 
      oprot.writeFieldEnd()
10714 
    oprot.writeFieldStop()
10715 
    oprot.writeStructEnd()
10716 
 
10717 
  def validate(self):
10718 
    return
10719 
 
10720 
 
10721 
  def __repr__(self):
10722 
    L = ['%s=%r' % (key, value)
10723 
      for key, value in self.__dict__.iteritems()]
10724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10725 
 
10726 
  def __eq__(self, other):
10727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10728 
 
10729 
  def __ne__(self, other):
10730 
    return not (self == other)
10731 
 
3064 chandransh 10732 
class markOrdersAsPickedUp_args:
304 ashish 10733 
  """
10734 
  Attributes:
3064 chandransh 10735 
   - providerId
10736 
   - pickupDetails
304 ashish 10737 
  """
94 ashish 10738 
 
304 ashish 10739 
  thrift_spec = (
10740 
    None, # 0
3064 chandransh 10741 
    (1, TType.I64, 'providerId', None, None, ), # 1
10742 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10743 
  )
10744 
 
3064 chandransh 10745 
  def __init__(self, providerId=None, pickupDetails=None,):
10746 
    self.providerId = providerId
10747 
    self.pickupDetails = pickupDetails
304 ashish 10748 
 
10749 
  def read(self, iprot):
10750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10752 
      return
10753 
    iprot.readStructBegin()
10754 
    while True:
10755 
      (fname, ftype, fid) = iprot.readFieldBegin()
10756 
      if ftype == TType.STOP:
10757 
        break
10758 
      if fid == 1:
10759 
        if ftype == TType.I64:
3064 chandransh 10760 
          self.providerId = iprot.readI64();
304 ashish 10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      elif fid == 2:
3064 chandransh 10764 
        if ftype == TType.MAP:
10765 
          self.pickupDetails = {}
4133 chandransh 10766 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10767 
          for _i144 in xrange(_size140):
10768 
            _key145 = iprot.readString();
10769 
            _val146 = iprot.readString();
10770 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10771 
          iprot.readMapEnd()
304 ashish 10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      else:
10775 
        iprot.skip(ftype)
10776 
      iprot.readFieldEnd()
10777 
    iprot.readStructEnd()
10778 
 
10779 
  def write(self, oprot):
10780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10782 
      return
3064 chandransh 10783 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10784 
    if self.providerId is not None:
3064 chandransh 10785 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10786 
      oprot.writeI64(self.providerId)
304 ashish 10787 
      oprot.writeFieldEnd()
3431 rajveer 10788 
    if self.pickupDetails is not None:
3064 chandransh 10789 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10790 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10791 
      for kiter147,viter148 in self.pickupDetails.items():
10792 
        oprot.writeString(kiter147)
10793 
        oprot.writeString(viter148)
3064 chandransh 10794 
      oprot.writeMapEnd()
304 ashish 10795 
      oprot.writeFieldEnd()
10796 
    oprot.writeFieldStop()
10797 
    oprot.writeStructEnd()
10798 
 
3431 rajveer 10799 
  def validate(self):
10800 
    return
10801 
 
10802 
 
304 ashish 10803 
  def __repr__(self):
10804 
    L = ['%s=%r' % (key, value)
10805 
      for key, value in self.__dict__.iteritems()]
10806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10807 
 
10808 
  def __eq__(self, other):
10809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10810 
 
10811 
  def __ne__(self, other):
10812 
    return not (self == other)
10813 
 
3064 chandransh 10814 
class markOrdersAsPickedUp_result:
304 ashish 10815 
  """
10816 
  Attributes:
10817 
   - success
3064 chandransh 10818 
   - ex
304 ashish 10819 
  """
10820 
 
10821 
  thrift_spec = (
3064 chandransh 10822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10824 
  )
10825 
 
3064 chandransh 10826 
  def __init__(self, success=None, ex=None,):
304 ashish 10827 
    self.success = success
3064 chandransh 10828 
    self.ex = ex
304 ashish 10829 
 
10830 
  def read(self, iprot):
10831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10833 
      return
10834 
    iprot.readStructBegin()
10835 
    while True:
10836 
      (fname, ftype, fid) = iprot.readFieldBegin()
10837 
      if ftype == TType.STOP:
10838 
        break
10839 
      if fid == 0:
10840 
        if ftype == TType.LIST:
10841 
          self.success = []
4133 chandransh 10842 
          (_etype152, _size149) = iprot.readListBegin()
10843 
          for _i153 in xrange(_size149):
10844 
            _elem154 = Order()
10845 
            _elem154.read(iprot)
10846 
            self.success.append(_elem154)
304 ashish 10847 
          iprot.readListEnd()
10848 
        else:
10849 
          iprot.skip(ftype)
3064 chandransh 10850 
      elif fid == 1:
10851 
        if ftype == TType.STRUCT:
10852 
          self.ex = TransactionServiceException()
10853 
          self.ex.read(iprot)
10854 
        else:
10855 
          iprot.skip(ftype)
304 ashish 10856 
      else:
10857 
        iprot.skip(ftype)
10858 
      iprot.readFieldEnd()
10859 
    iprot.readStructEnd()
10860 
 
10861 
  def write(self, oprot):
10862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10864 
      return
3064 chandransh 10865 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10866 
    if self.success is not None:
304 ashish 10867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10869 
      for iter155 in self.success:
10870 
        iter155.write(oprot)
304 ashish 10871 
      oprot.writeListEnd()
10872 
      oprot.writeFieldEnd()
3431 rajveer 10873 
    if self.ex is not None:
3064 chandransh 10874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10875 
      self.ex.write(oprot)
10876 
      oprot.writeFieldEnd()
304 ashish 10877 
    oprot.writeFieldStop()
10878 
    oprot.writeStructEnd()
10879 
 
3431 rajveer 10880 
  def validate(self):
10881 
    return
10882 
 
10883 
 
304 ashish 10884 
  def __repr__(self):
10885 
    L = ['%s=%r' % (key, value)
10886 
      for key, value in self.__dict__.iteritems()]
10887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10888 
 
10889 
  def __eq__(self, other):
10890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10891 
 
10892 
  def __ne__(self, other):
10893 
    return not (self == other)
10894 
 
3064 chandransh 10895 
class markOrdersAsDelivered_args:
304 ashish 10896 
  """
10897 
  Attributes:
3064 chandransh 10898 
   - providerId
10899 
   - deliveredOrders
304 ashish 10900 
  """
10901 
 
10902 
  thrift_spec = (
10903 
    None, # 0
3064 chandransh 10904 
    (1, TType.I64, 'providerId', None, None, ), # 1
10905 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10906 
  )
10907 
 
3064 chandransh 10908 
  def __init__(self, providerId=None, deliveredOrders=None,):
10909 
    self.providerId = providerId
10910 
    self.deliveredOrders = deliveredOrders
304 ashish 10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      if fid == 1:
10922 
        if ftype == TType.I64:
3064 chandransh 10923 
          self.providerId = iprot.readI64();
304 ashish 10924 
        else:
10925 
          iprot.skip(ftype)
10926 
      elif fid == 2:
3064 chandransh 10927 
        if ftype == TType.MAP:
10928 
          self.deliveredOrders = {}
4133 chandransh 10929 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10930 
          for _i160 in xrange(_size156):
10931 
            _key161 = iprot.readString();
10932 
            _val162 = iprot.readString();
10933 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10934 
          iprot.readMapEnd()
304 ashish 10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      else:
10938 
        iprot.skip(ftype)
10939 
      iprot.readFieldEnd()
10940 
    iprot.readStructEnd()
10941 
 
10942 
  def write(self, oprot):
10943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10945 
      return
3064 chandransh 10946 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10947 
    if self.providerId is not None:
3064 chandransh 10948 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10949 
      oprot.writeI64(self.providerId)
304 ashish 10950 
      oprot.writeFieldEnd()
3431 rajveer 10951 
    if self.deliveredOrders is not None:
3064 chandransh 10952 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10953 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10954 
      for kiter163,viter164 in self.deliveredOrders.items():
10955 
        oprot.writeString(kiter163)
10956 
        oprot.writeString(viter164)
3064 chandransh 10957 
      oprot.writeMapEnd()
304 ashish 10958 
      oprot.writeFieldEnd()
10959 
    oprot.writeFieldStop()
10960 
    oprot.writeStructEnd()
10961 
 
3431 rajveer 10962 
  def validate(self):
10963 
    return
10964 
 
10965 
 
304 ashish 10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
3064 chandransh 10977 
class markOrdersAsDelivered_result:
10978 
  """
10979 
  Attributes:
10980 
   - ex
10981 
  """
304 ashish 10982 
 
10983 
  thrift_spec = (
3064 chandransh 10984 
    None, # 0
10985 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10986 
  )
10987 
 
3064 chandransh 10988 
  def __init__(self, ex=None,):
10989 
    self.ex = ex
304 ashish 10990 
 
1596 ankur.sing 10991 
  def read(self, iprot):
10992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10994 
      return
10995 
    iprot.readStructBegin()
10996 
    while True:
10997 
      (fname, ftype, fid) = iprot.readFieldBegin()
10998 
      if ftype == TType.STOP:
10999 
        break
3064 chandransh 11000 
      if fid == 1:
11001 
        if ftype == TType.STRUCT:
11002 
          self.ex = TransactionServiceException()
11003 
          self.ex.read(iprot)
11004 
        else:
11005 
          iprot.skip(ftype)
1596 ankur.sing 11006 
      else:
11007 
        iprot.skip(ftype)
11008 
      iprot.readFieldEnd()
11009 
    iprot.readStructEnd()
11010 
 
11011 
  def write(self, oprot):
11012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11014 
      return
3064 chandransh 11015 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11016 
    if self.ex is not None:
3064 chandransh 11017 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11018 
      self.ex.write(oprot)
11019 
      oprot.writeFieldEnd()
1596 ankur.sing 11020 
    oprot.writeFieldStop()
11021 
    oprot.writeStructEnd()
11022 
 
3431 rajveer 11023 
  def validate(self):
11024 
    return
11025 
 
11026 
 
1596 ankur.sing 11027 
  def __repr__(self):
11028 
    L = ['%s=%r' % (key, value)
11029 
      for key, value in self.__dict__.iteritems()]
11030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11031 
 
11032 
  def __eq__(self, other):
11033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11034 
 
11035 
  def __ne__(self, other):
11036 
    return not (self == other)
11037 
 
3064 chandransh 11038 
class markOrdersAsFailed_args:
1596 ankur.sing 11039 
  """
11040 
  Attributes:
3064 chandransh 11041 
   - providerId
11042 
   - returnedOrders
1596 ankur.sing 11043 
  """
11044 
 
11045 
  thrift_spec = (
3064 chandransh 11046 
    None, # 0
11047 
    (1, TType.I64, 'providerId', None, None, ), # 1
11048 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11049 
  )
11050 
 
3064 chandransh 11051 
  def __init__(self, providerId=None, returnedOrders=None,):
11052 
    self.providerId = providerId
11053 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11054 
 
11055 
  def read(self, iprot):
11056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11058 
      return
11059 
    iprot.readStructBegin()
11060 
    while True:
11061 
      (fname, ftype, fid) = iprot.readFieldBegin()
11062 
      if ftype == TType.STOP:
11063 
        break
3064 chandransh 11064 
      if fid == 1:
1596 ankur.sing 11065 
        if ftype == TType.I64:
3064 chandransh 11066 
          self.providerId = iprot.readI64();
1596 ankur.sing 11067 
        else:
11068 
          iprot.skip(ftype)
3064 chandransh 11069 
      elif fid == 2:
11070 
        if ftype == TType.MAP:
11071 
          self.returnedOrders = {}
4133 chandransh 11072 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11073 
          for _i169 in xrange(_size165):
11074 
            _key170 = iprot.readString();
11075 
            _val171 = iprot.readString();
11076 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11077 
          iprot.readMapEnd()
11078 
        else:
11079 
          iprot.skip(ftype)
1596 ankur.sing 11080 
      else:
11081 
        iprot.skip(ftype)
11082 
      iprot.readFieldEnd()
11083 
    iprot.readStructEnd()
11084 
 
11085 
  def write(self, oprot):
11086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11088 
      return
3064 chandransh 11089 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11090 
    if self.providerId is not None:
3064 chandransh 11091 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11092 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11093 
      oprot.writeFieldEnd()
3431 rajveer 11094 
    if self.returnedOrders is not None:
3064 chandransh 11095 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11096 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11097 
      for kiter172,viter173 in self.returnedOrders.items():
11098 
        oprot.writeString(kiter172)
11099 
        oprot.writeString(viter173)
3064 chandransh 11100 
      oprot.writeMapEnd()
11101 
      oprot.writeFieldEnd()
1596 ankur.sing 11102 
    oprot.writeFieldStop()
11103 
    oprot.writeStructEnd()
11104 
 
3431 rajveer 11105 
  def validate(self):
11106 
    return
11107 
 
11108 
 
1596 ankur.sing 11109 
  def __repr__(self):
11110 
    L = ['%s=%r' % (key, value)
11111 
      for key, value in self.__dict__.iteritems()]
11112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11113 
 
11114 
  def __eq__(self, other):
11115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11116 
 
11117 
  def __ne__(self, other):
11118 
    return not (self == other)
11119 
 
3064 chandransh 11120 
class markOrdersAsFailed_result:
11121 
  """
11122 
  Attributes:
11123 
   - ex
11124 
  """
1596 ankur.sing 11125 
 
1627 ankur.sing 11126 
  thrift_spec = (
3064 chandransh 11127 
    None, # 0
11128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11129 
  )
11130 
 
3064 chandransh 11131 
  def __init__(self, ex=None,):
11132 
    self.ex = ex
11133 
 
1627 ankur.sing 11134 
  def read(self, iprot):
11135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11137 
      return
11138 
    iprot.readStructBegin()
11139 
    while True:
11140 
      (fname, ftype, fid) = iprot.readFieldBegin()
11141 
      if ftype == TType.STOP:
11142 
        break
3064 chandransh 11143 
      if fid == 1:
11144 
        if ftype == TType.STRUCT:
11145 
          self.ex = TransactionServiceException()
11146 
          self.ex.read(iprot)
11147 
        else:
11148 
          iprot.skip(ftype)
1627 ankur.sing 11149 
      else:
11150 
        iprot.skip(ftype)
11151 
      iprot.readFieldEnd()
11152 
    iprot.readStructEnd()
11153 
 
11154 
  def write(self, oprot):
11155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11157 
      return
3064 chandransh 11158 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11159 
    if self.ex is not None:
3064 chandransh 11160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11161 
      self.ex.write(oprot)
11162 
      oprot.writeFieldEnd()
1627 ankur.sing 11163 
    oprot.writeFieldStop()
11164 
    oprot.writeStructEnd()
11165 
 
3431 rajveer 11166 
  def validate(self):
11167 
    return
11168 
 
11169 
 
1627 ankur.sing 11170 
  def __repr__(self):
11171 
    L = ['%s=%r' % (key, value)
11172 
      for key, value in self.__dict__.iteritems()]
11173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11174 
 
11175 
  def __eq__(self, other):
11176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11177 
 
11178 
  def __ne__(self, other):
11179 
    return not (self == other)
11180 
 
3064 chandransh 11181 
class updateNonDeliveryReason_args:
1627 ankur.sing 11182 
  """
11183 
  Attributes:
3064 chandransh 11184 
   - providerId
11185 
   - undeliveredOrders
1627 ankur.sing 11186 
  """
11187 
 
11188 
  thrift_spec = (
3064 chandransh 11189 
    None, # 0
11190 
    (1, TType.I64, 'providerId', None, None, ), # 1
11191 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11192 
  )
11193 
 
3064 chandransh 11194 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11195 
    self.providerId = providerId
11196 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11197 
 
11198 
  def read(self, iprot):
11199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11201 
      return
11202 
    iprot.readStructBegin()
11203 
    while True:
11204 
      (fname, ftype, fid) = iprot.readFieldBegin()
11205 
      if ftype == TType.STOP:
11206 
        break
3064 chandransh 11207 
      if fid == 1:
1627 ankur.sing 11208 
        if ftype == TType.I64:
3064 chandransh 11209 
          self.providerId = iprot.readI64();
1627 ankur.sing 11210 
        else:
11211 
          iprot.skip(ftype)
3064 chandransh 11212 
      elif fid == 2:
11213 
        if ftype == TType.MAP:
11214 
          self.undeliveredOrders = {}
4133 chandransh 11215 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11216 
          for _i178 in xrange(_size174):
11217 
            _key179 = iprot.readString();
11218 
            _val180 = iprot.readString();
11219 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11220 
          iprot.readMapEnd()
11221 
        else:
11222 
          iprot.skip(ftype)
1627 ankur.sing 11223 
      else:
11224 
        iprot.skip(ftype)
11225 
      iprot.readFieldEnd()
11226 
    iprot.readStructEnd()
11227 
 
11228 
  def write(self, oprot):
11229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11231 
      return
3064 chandransh 11232 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11233 
    if self.providerId is not None:
3064 chandransh 11234 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11235 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11236 
      oprot.writeFieldEnd()
3431 rajveer 11237 
    if self.undeliveredOrders is not None:
3064 chandransh 11238 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11239 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11240 
      for kiter181,viter182 in self.undeliveredOrders.items():
11241 
        oprot.writeString(kiter181)
11242 
        oprot.writeString(viter182)
3064 chandransh 11243 
      oprot.writeMapEnd()
11244 
      oprot.writeFieldEnd()
1627 ankur.sing 11245 
    oprot.writeFieldStop()
11246 
    oprot.writeStructEnd()
11247 
 
3431 rajveer 11248 
  def validate(self):
11249 
    return
11250 
 
11251 
 
1627 ankur.sing 11252 
  def __repr__(self):
11253 
    L = ['%s=%r' % (key, value)
11254 
      for key, value in self.__dict__.iteritems()]
11255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11256 
 
11257 
  def __eq__(self, other):
11258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11259 
 
11260 
  def __ne__(self, other):
11261 
    return not (self == other)
11262 
 
3064 chandransh 11263 
class updateNonDeliveryReason_result:
1627 ankur.sing 11264 
  """
11265 
  Attributes:
4581 phani.kuma 11266 
   - success
3064 chandransh 11267 
   - ex
1627 ankur.sing 11268 
  """
11269 
 
11270 
  thrift_spec = (
4581 phani.kuma 11271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11273 
  )
11274 
 
4581 phani.kuma 11275 
  def __init__(self, success=None, ex=None,):
11276 
    self.success = success
3064 chandransh 11277 
    self.ex = ex
1627 ankur.sing 11278 
 
11279 
  def read(self, iprot):
11280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11282 
      return
11283 
    iprot.readStructBegin()
11284 
    while True:
11285 
      (fname, ftype, fid) = iprot.readFieldBegin()
11286 
      if ftype == TType.STOP:
11287 
        break
4581 phani.kuma 11288 
      if fid == 0:
11289 
        if ftype == TType.LIST:
11290 
          self.success = []
11291 
          (_etype186, _size183) = iprot.readListBegin()
11292 
          for _i187 in xrange(_size183):
11293 
            _elem188 = Order()
11294 
            _elem188.read(iprot)
11295 
            self.success.append(_elem188)
11296 
          iprot.readListEnd()
11297 
        else:
11298 
          iprot.skip(ftype)
11299 
      elif fid == 1:
3064 chandransh 11300 
        if ftype == TType.STRUCT:
11301 
          self.ex = TransactionServiceException()
11302 
          self.ex.read(iprot)
1627 ankur.sing 11303 
        else:
11304 
          iprot.skip(ftype)
11305 
      else:
11306 
        iprot.skip(ftype)
11307 
      iprot.readFieldEnd()
11308 
    iprot.readStructEnd()
11309 
 
11310 
  def write(self, oprot):
11311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11313 
      return
3064 chandransh 11314 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11315 
    if self.success is not None:
11316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11318 
      for iter189 in self.success:
11319 
        iter189.write(oprot)
11320 
      oprot.writeListEnd()
11321 
      oprot.writeFieldEnd()
3431 rajveer 11322 
    if self.ex is not None:
3064 chandransh 11323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11324 
      self.ex.write(oprot)
1627 ankur.sing 11325 
      oprot.writeFieldEnd()
11326 
    oprot.writeFieldStop()
11327 
    oprot.writeStructEnd()
11328 
 
3431 rajveer 11329 
  def validate(self):
11330 
    return
11331 
 
11332 
 
1627 ankur.sing 11333 
  def __repr__(self):
11334 
    L = ['%s=%r' % (key, value)
11335 
      for key, value in self.__dict__.iteritems()]
11336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11337 
 
11338 
  def __eq__(self, other):
11339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11340 
 
11341 
  def __ne__(self, other):
11342 
    return not (self == other)
11343 
 
3064 chandransh 11344 
class getUndeliveredOrders_args:
1886 ankur.sing 11345 
  """
11346 
  Attributes:
3064 chandransh 11347 
   - providerId
11348 
   - warehouseId
1886 ankur.sing 11349 
  """
1627 ankur.sing 11350 
 
1886 ankur.sing 11351 
  thrift_spec = (
11352 
    None, # 0
3064 chandransh 11353 
    (1, TType.I64, 'providerId', None, None, ), # 1
11354 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11355 
  )
11356 
 
3064 chandransh 11357 
  def __init__(self, providerId=None, warehouseId=None,):
11358 
    self.providerId = providerId
11359 
    self.warehouseId = warehouseId
1886 ankur.sing 11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 1:
11371 
        if ftype == TType.I64:
3064 chandransh 11372 
          self.providerId = iprot.readI64();
1886 ankur.sing 11373 
        else:
11374 
          iprot.skip(ftype)
3064 chandransh 11375 
      elif fid == 2:
11376 
        if ftype == TType.I64:
11377 
          self.warehouseId = iprot.readI64();
11378 
        else:
11379 
          iprot.skip(ftype)
1886 ankur.sing 11380 
      else:
11381 
        iprot.skip(ftype)
11382 
      iprot.readFieldEnd()
11383 
    iprot.readStructEnd()
11384 
 
11385 
  def write(self, oprot):
11386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11388 
      return
3064 chandransh 11389 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11390 
    if self.providerId is not None:
3064 chandransh 11391 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11392 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11393 
      oprot.writeFieldEnd()
3431 rajveer 11394 
    if self.warehouseId is not None:
3064 chandransh 11395 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11396 
      oprot.writeI64(self.warehouseId)
11397 
      oprot.writeFieldEnd()
1886 ankur.sing 11398 
    oprot.writeFieldStop()
11399 
    oprot.writeStructEnd()
11400 
 
3431 rajveer 11401 
  def validate(self):
11402 
    return
11403 
 
11404 
 
1886 ankur.sing 11405 
  def __repr__(self):
11406 
    L = ['%s=%r' % (key, value)
11407 
      for key, value in self.__dict__.iteritems()]
11408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11409 
 
11410 
  def __eq__(self, other):
11411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11412 
 
11413 
  def __ne__(self, other):
11414 
    return not (self == other)
11415 
 
3064 chandransh 11416 
class getUndeliveredOrders_result:
1886 ankur.sing 11417 
  """
11418 
  Attributes:
11419 
   - success
11420 
  """
11421 
 
11422 
  thrift_spec = (
11423 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11424 
  )
11425 
 
11426 
  def __init__(self, success=None,):
11427 
    self.success = success
11428 
 
11429 
  def read(self, iprot):
11430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11432 
      return
11433 
    iprot.readStructBegin()
11434 
    while True:
11435 
      (fname, ftype, fid) = iprot.readFieldBegin()
11436 
      if ftype == TType.STOP:
11437 
        break
11438 
      if fid == 0:
11439 
        if ftype == TType.LIST:
11440 
          self.success = []
4581 phani.kuma 11441 
          (_etype193, _size190) = iprot.readListBegin()
11442 
          for _i194 in xrange(_size190):
11443 
            _elem195 = Order()
11444 
            _elem195.read(iprot)
11445 
            self.success.append(_elem195)
1886 ankur.sing 11446 
          iprot.readListEnd()
11447 
        else:
11448 
          iprot.skip(ftype)
11449 
      else:
11450 
        iprot.skip(ftype)
11451 
      iprot.readFieldEnd()
11452 
    iprot.readStructEnd()
11453 
 
11454 
  def write(self, oprot):
11455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11457 
      return
3064 chandransh 11458 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11459 
    if self.success is not None:
1886 ankur.sing 11460 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11461 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11462 
      for iter196 in self.success:
11463 
        iter196.write(oprot)
1886 ankur.sing 11464 
      oprot.writeListEnd()
11465 
      oprot.writeFieldEnd()
11466 
    oprot.writeFieldStop()
11467 
    oprot.writeStructEnd()
11468 
 
3431 rajveer 11469 
  def validate(self):
11470 
    return
11471 
 
11472 
 
1886 ankur.sing 11473 
  def __repr__(self):
11474 
    L = ['%s=%r' % (key, value)
11475 
      for key, value in self.__dict__.iteritems()]
11476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11477 
 
11478 
  def __eq__(self, other):
11479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11480 
 
11481 
  def __ne__(self, other):
11482 
    return not (self == other)
11483 
 
2536 chandransh 11484 
class toggleDOAFlag_args:
11485 
  """
11486 
  Attributes:
11487 
   - orderId
11488 
  """
1886 ankur.sing 11489 
 
2536 chandransh 11490 
  thrift_spec = (
11491 
    None, # 0
11492 
    (1, TType.I64, 'orderId', None, None, ), # 1
11493 
  )
11494 
 
11495 
  def __init__(self, orderId=None,):
11496 
    self.orderId = orderId
11497 
 
11498 
  def read(self, iprot):
11499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11501 
      return
11502 
    iprot.readStructBegin()
11503 
    while True:
11504 
      (fname, ftype, fid) = iprot.readFieldBegin()
11505 
      if ftype == TType.STOP:
11506 
        break
11507 
      if fid == 1:
11508 
        if ftype == TType.I64:
11509 
          self.orderId = iprot.readI64();
11510 
        else:
11511 
          iprot.skip(ftype)
11512 
      else:
11513 
        iprot.skip(ftype)
11514 
      iprot.readFieldEnd()
11515 
    iprot.readStructEnd()
11516 
 
11517 
  def write(self, oprot):
11518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11520 
      return
11521 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11522 
    if self.orderId is not None:
2536 chandransh 11523 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11524 
      oprot.writeI64(self.orderId)
11525 
      oprot.writeFieldEnd()
11526 
    oprot.writeFieldStop()
11527 
    oprot.writeStructEnd()
11528 
 
3431 rajveer 11529 
  def validate(self):
11530 
    return
11531 
 
11532 
 
2536 chandransh 11533 
  def __repr__(self):
11534 
    L = ['%s=%r' % (key, value)
11535 
      for key, value in self.__dict__.iteritems()]
11536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11537 
 
11538 
  def __eq__(self, other):
11539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11540 
 
11541 
  def __ne__(self, other):
11542 
    return not (self == other)
11543 
 
11544 
class toggleDOAFlag_result:
11545 
  """
11546 
  Attributes:
11547 
   - success
11548 
   - ex
11549 
  """
11550 
 
11551 
  thrift_spec = (
11552 
    (0, TType.BOOL, 'success', None, None, ), # 0
11553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11554 
  )
11555 
 
11556 
  def __init__(self, success=None, ex=None,):
11557 
    self.success = success
11558 
    self.ex = ex
11559 
 
11560 
  def read(self, iprot):
11561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11563 
      return
11564 
    iprot.readStructBegin()
11565 
    while True:
11566 
      (fname, ftype, fid) = iprot.readFieldBegin()
11567 
      if ftype == TType.STOP:
11568 
        break
11569 
      if fid == 0:
11570 
        if ftype == TType.BOOL:
11571 
          self.success = iprot.readBool();
11572 
        else:
11573 
          iprot.skip(ftype)
11574 
      elif fid == 1:
11575 
        if ftype == TType.STRUCT:
11576 
          self.ex = TransactionServiceException()
11577 
          self.ex.read(iprot)
11578 
        else:
11579 
          iprot.skip(ftype)
11580 
      else:
11581 
        iprot.skip(ftype)
11582 
      iprot.readFieldEnd()
11583 
    iprot.readStructEnd()
11584 
 
11585 
  def write(self, oprot):
11586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11588 
      return
11589 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11590 
    if self.success is not None:
2536 chandransh 11591 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11592 
      oprot.writeBool(self.success)
11593 
      oprot.writeFieldEnd()
3431 rajveer 11594 
    if self.ex is not None:
2536 chandransh 11595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11596 
      self.ex.write(oprot)
11597 
      oprot.writeFieldEnd()
11598 
    oprot.writeFieldStop()
11599 
    oprot.writeStructEnd()
11600 
 
3431 rajveer 11601 
  def validate(self):
11602 
    return
11603 
 
11604 
 
2536 chandransh 11605 
  def __repr__(self):
11606 
    L = ['%s=%r' % (key, value)
11607 
      for key, value in self.__dict__.iteritems()]
11608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11609 
 
11610 
  def __eq__(self, other):
11611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11612 
 
11613 
  def __ne__(self, other):
11614 
    return not (self == other)
11615 
 
4454 rajveer 11616 
class markOrderDoaRequestReceived_args:
11617 
  """
11618 
  Attributes:
11619 
   - orderId
11620 
  """
11621 
 
11622 
  thrift_spec = (
11623 
    None, # 0
11624 
    (1, TType.I64, 'orderId', None, None, ), # 1
11625 
  )
11626 
 
11627 
  def __init__(self, orderId=None,):
11628 
    self.orderId = orderId
11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
11639 
      if fid == 1:
11640 
        if ftype == TType.I64:
11641 
          self.orderId = iprot.readI64();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11654 
    if self.orderId is not None:
11655 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11656 
      oprot.writeI64(self.orderId)
11657 
      oprot.writeFieldEnd()
11658 
    oprot.writeFieldStop()
11659 
    oprot.writeStructEnd()
11660 
 
11661 
  def validate(self):
11662 
    return
11663 
 
11664 
 
11665 
  def __repr__(self):
11666 
    L = ['%s=%r' % (key, value)
11667 
      for key, value in self.__dict__.iteritems()]
11668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11669 
 
11670 
  def __eq__(self, other):
11671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11672 
 
11673 
  def __ne__(self, other):
11674 
    return not (self == other)
11675 
 
11676 
class markOrderDoaRequestReceived_result:
11677 
  """
11678 
  Attributes:
11679 
   - success
11680 
   - ex
11681 
  """
11682 
 
11683 
  thrift_spec = (
11684 
    (0, TType.BOOL, 'success', None, None, ), # 0
11685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11686 
  )
11687 
 
11688 
  def __init__(self, success=None, ex=None,):
11689 
    self.success = success
11690 
    self.ex = ex
11691 
 
11692 
  def read(self, iprot):
11693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11695 
      return
11696 
    iprot.readStructBegin()
11697 
    while True:
11698 
      (fname, ftype, fid) = iprot.readFieldBegin()
11699 
      if ftype == TType.STOP:
11700 
        break
11701 
      if fid == 0:
11702 
        if ftype == TType.BOOL:
11703 
          self.success = iprot.readBool();
11704 
        else:
11705 
          iprot.skip(ftype)
11706 
      elif fid == 1:
11707 
        if ftype == TType.STRUCT:
11708 
          self.ex = TransactionServiceException()
11709 
          self.ex.read(iprot)
11710 
        else:
11711 
          iprot.skip(ftype)
11712 
      else:
11713 
        iprot.skip(ftype)
11714 
      iprot.readFieldEnd()
11715 
    iprot.readStructEnd()
11716 
 
11717 
  def write(self, oprot):
11718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11720 
      return
11721 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11722 
    if self.success is not None:
11723 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11724 
      oprot.writeBool(self.success)
11725 
      oprot.writeFieldEnd()
11726 
    if self.ex is not None:
11727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11728 
      self.ex.write(oprot)
11729 
      oprot.writeFieldEnd()
11730 
    oprot.writeFieldStop()
11731 
    oprot.writeStructEnd()
11732 
 
11733 
  def validate(self):
11734 
    return
11735 
 
11736 
 
11737 
  def __repr__(self):
11738 
    L = ['%s=%r' % (key, value)
11739 
      for key, value in self.__dict__.iteritems()]
11740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11741 
 
11742 
  def __eq__(self, other):
11743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11744 
 
11745 
  def __ne__(self, other):
11746 
    return not (self == other)
11747 
 
11748 
class markOrderDoaRequestAuthorized_args:
11749 
  """
11750 
  Attributes:
11751 
   - orderId
11752 
   - isAuthorized
11753 
  """
11754 
 
11755 
  thrift_spec = (
11756 
    None, # 0
11757 
    (1, TType.I64, 'orderId', None, None, ), # 1
11758 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11759 
  )
11760 
 
11761 
  def __init__(self, orderId=None, isAuthorized=None,):
11762 
    self.orderId = orderId
11763 
    self.isAuthorized = isAuthorized
11764 
 
11765 
  def read(self, iprot):
11766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11768 
      return
11769 
    iprot.readStructBegin()
11770 
    while True:
11771 
      (fname, ftype, fid) = iprot.readFieldBegin()
11772 
      if ftype == TType.STOP:
11773 
        break
11774 
      if fid == 1:
11775 
        if ftype == TType.I64:
11776 
          self.orderId = iprot.readI64();
11777 
        else:
11778 
          iprot.skip(ftype)
11779 
      elif fid == 2:
11780 
        if ftype == TType.BOOL:
11781 
          self.isAuthorized = iprot.readBool();
11782 
        else:
11783 
          iprot.skip(ftype)
11784 
      else:
11785 
        iprot.skip(ftype)
11786 
      iprot.readFieldEnd()
11787 
    iprot.readStructEnd()
11788 
 
11789 
  def write(self, oprot):
11790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11792 
      return
11793 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11794 
    if self.orderId is not None:
11795 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11796 
      oprot.writeI64(self.orderId)
11797 
      oprot.writeFieldEnd()
11798 
    if self.isAuthorized is not None:
11799 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11800 
      oprot.writeBool(self.isAuthorized)
11801 
      oprot.writeFieldEnd()
11802 
    oprot.writeFieldStop()
11803 
    oprot.writeStructEnd()
11804 
 
11805 
  def validate(self):
11806 
    return
11807 
 
11808 
 
11809 
  def __repr__(self):
11810 
    L = ['%s=%r' % (key, value)
11811 
      for key, value in self.__dict__.iteritems()]
11812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11813 
 
11814 
  def __eq__(self, other):
11815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11816 
 
11817 
  def __ne__(self, other):
11818 
    return not (self == other)
11819 
 
11820 
class markOrderDoaRequestAuthorized_result:
11821 
  """
11822 
  Attributes:
11823 
   - success
11824 
   - ex
11825 
  """
11826 
 
11827 
  thrift_spec = (
11828 
    (0, TType.BOOL, 'success', None, None, ), # 0
11829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11830 
  )
11831 
 
11832 
  def __init__(self, success=None, ex=None,):
11833 
    self.success = success
11834 
    self.ex = ex
11835 
 
11836 
  def read(self, iprot):
11837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11839 
      return
11840 
    iprot.readStructBegin()
11841 
    while True:
11842 
      (fname, ftype, fid) = iprot.readFieldBegin()
11843 
      if ftype == TType.STOP:
11844 
        break
11845 
      if fid == 0:
11846 
        if ftype == TType.BOOL:
11847 
          self.success = iprot.readBool();
11848 
        else:
11849 
          iprot.skip(ftype)
11850 
      elif fid == 1:
11851 
        if ftype == TType.STRUCT:
11852 
          self.ex = TransactionServiceException()
11853 
          self.ex.read(iprot)
11854 
        else:
11855 
          iprot.skip(ftype)
11856 
      else:
11857 
        iprot.skip(ftype)
11858 
      iprot.readFieldEnd()
11859 
    iprot.readStructEnd()
11860 
 
11861 
  def write(self, oprot):
11862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11864 
      return
11865 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11866 
    if self.success is not None:
11867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11868 
      oprot.writeBool(self.success)
11869 
      oprot.writeFieldEnd()
11870 
    if self.ex is not None:
11871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11872 
      self.ex.write(oprot)
11873 
      oprot.writeFieldEnd()
11874 
    oprot.writeFieldStop()
11875 
    oprot.writeStructEnd()
11876 
 
11877 
  def validate(self):
11878 
    return
11879 
 
11880 
 
11881 
  def __repr__(self):
11882 
    L = ['%s=%r' % (key, value)
11883 
      for key, value in self.__dict__.iteritems()]
11884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11885 
 
11886 
  def __eq__(self, other):
11887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11888 
 
11889 
  def __ne__(self, other):
11890 
    return not (self == other)
11891 
 
4488 rajveer 11892 
class markOrderReturnRequestReceived_args:
11893 
  """
11894 
  Attributes:
11895 
   - orderId
11896 
  """
11897 
 
11898 
  thrift_spec = (
11899 
    None, # 0
11900 
    (1, TType.I64, 'orderId', None, None, ), # 1
11901 
  )
11902 
 
11903 
  def __init__(self, orderId=None,):
11904 
    self.orderId = orderId
11905 
 
11906 
  def read(self, iprot):
11907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11909 
      return
11910 
    iprot.readStructBegin()
11911 
    while True:
11912 
      (fname, ftype, fid) = iprot.readFieldBegin()
11913 
      if ftype == TType.STOP:
11914 
        break
11915 
      if fid == 1:
11916 
        if ftype == TType.I64:
11917 
          self.orderId = iprot.readI64();
11918 
        else:
11919 
          iprot.skip(ftype)
11920 
      else:
11921 
        iprot.skip(ftype)
11922 
      iprot.readFieldEnd()
11923 
    iprot.readStructEnd()
11924 
 
11925 
  def write(self, oprot):
11926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11928 
      return
11929 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11930 
    if self.orderId is not None:
11931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11932 
      oprot.writeI64(self.orderId)
11933 
      oprot.writeFieldEnd()
11934 
    oprot.writeFieldStop()
11935 
    oprot.writeStructEnd()
11936 
 
11937 
  def validate(self):
11938 
    return
11939 
 
11940 
 
11941 
  def __repr__(self):
11942 
    L = ['%s=%r' % (key, value)
11943 
      for key, value in self.__dict__.iteritems()]
11944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11945 
 
11946 
  def __eq__(self, other):
11947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11948 
 
11949 
  def __ne__(self, other):
11950 
    return not (self == other)
11951 
 
11952 
class markOrderReturnRequestReceived_result:
11953 
  """
11954 
  Attributes:
11955 
   - success
11956 
   - ex
11957 
  """
11958 
 
11959 
  thrift_spec = (
11960 
    (0, TType.BOOL, 'success', None, None, ), # 0
11961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11962 
  )
11963 
 
11964 
  def __init__(self, success=None, ex=None,):
11965 
    self.success = success
11966 
    self.ex = ex
11967 
 
11968 
  def read(self, iprot):
11969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11971 
      return
11972 
    iprot.readStructBegin()
11973 
    while True:
11974 
      (fname, ftype, fid) = iprot.readFieldBegin()
11975 
      if ftype == TType.STOP:
11976 
        break
11977 
      if fid == 0:
11978 
        if ftype == TType.BOOL:
11979 
          self.success = iprot.readBool();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      elif fid == 1:
11983 
        if ftype == TType.STRUCT:
11984 
          self.ex = TransactionServiceException()
11985 
          self.ex.read(iprot)
11986 
        else:
11987 
          iprot.skip(ftype)
11988 
      else:
11989 
        iprot.skip(ftype)
11990 
      iprot.readFieldEnd()
11991 
    iprot.readStructEnd()
11992 
 
11993 
  def write(self, oprot):
11994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11996 
      return
11997 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11998 
    if self.success is not None:
11999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12000 
      oprot.writeBool(self.success)
12001 
      oprot.writeFieldEnd()
12002 
    if self.ex is not None:
12003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12004 
      self.ex.write(oprot)
12005 
      oprot.writeFieldEnd()
12006 
    oprot.writeFieldStop()
12007 
    oprot.writeStructEnd()
12008 
 
12009 
  def validate(self):
12010 
    return
12011 
 
12012 
 
12013 
  def __repr__(self):
12014 
    L = ['%s=%r' % (key, value)
12015 
      for key, value in self.__dict__.iteritems()]
12016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12017 
 
12018 
  def __eq__(self, other):
12019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12020 
 
12021 
  def __ne__(self, other):
12022 
    return not (self == other)
12023 
 
12024 
class markOrderReturnRequestAuthorized_args:
12025 
  """
12026 
  Attributes:
12027 
   - orderId
12028 
   - isAuthorized
12029 
  """
12030 
 
12031 
  thrift_spec = (
12032 
    None, # 0
12033 
    (1, TType.I64, 'orderId', None, None, ), # 1
12034 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12035 
  )
12036 
 
12037 
  def __init__(self, orderId=None, isAuthorized=None,):
12038 
    self.orderId = orderId
12039 
    self.isAuthorized = isAuthorized
12040 
 
12041 
  def read(self, iprot):
12042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12044 
      return
12045 
    iprot.readStructBegin()
12046 
    while True:
12047 
      (fname, ftype, fid) = iprot.readFieldBegin()
12048 
      if ftype == TType.STOP:
12049 
        break
12050 
      if fid == 1:
12051 
        if ftype == TType.I64:
12052 
          self.orderId = iprot.readI64();
12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      elif fid == 2:
12056 
        if ftype == TType.BOOL:
12057 
          self.isAuthorized = iprot.readBool();
12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
12069 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12070 
    if self.orderId is not None:
12071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12072 
      oprot.writeI64(self.orderId)
12073 
      oprot.writeFieldEnd()
12074 
    if self.isAuthorized is not None:
12075 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12076 
      oprot.writeBool(self.isAuthorized)
12077 
      oprot.writeFieldEnd()
12078 
    oprot.writeFieldStop()
12079 
    oprot.writeStructEnd()
12080 
 
12081 
  def validate(self):
12082 
    return
12083 
 
12084 
 
12085 
  def __repr__(self):
12086 
    L = ['%s=%r' % (key, value)
12087 
      for key, value in self.__dict__.iteritems()]
12088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12089 
 
12090 
  def __eq__(self, other):
12091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12092 
 
12093 
  def __ne__(self, other):
12094 
    return not (self == other)
12095 
 
12096 
class markOrderReturnRequestAuthorized_result:
12097 
  """
12098 
  Attributes:
12099 
   - success
12100 
   - ex
12101 
  """
12102 
 
12103 
  thrift_spec = (
12104 
    (0, TType.BOOL, 'success', None, None, ), # 0
12105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12106 
  )
12107 
 
12108 
  def __init__(self, success=None, ex=None,):
12109 
    self.success = success
12110 
    self.ex = ex
12111 
 
12112 
  def read(self, iprot):
12113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12115 
      return
12116 
    iprot.readStructBegin()
12117 
    while True:
12118 
      (fname, ftype, fid) = iprot.readFieldBegin()
12119 
      if ftype == TType.STOP:
12120 
        break
12121 
      if fid == 0:
12122 
        if ftype == TType.BOOL:
12123 
          self.success = iprot.readBool();
12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      elif fid == 1:
12127 
        if ftype == TType.STRUCT:
12128 
          self.ex = TransactionServiceException()
12129 
          self.ex.read(iprot)
12130 
        else:
12131 
          iprot.skip(ftype)
12132 
      else:
12133 
        iprot.skip(ftype)
12134 
      iprot.readFieldEnd()
12135 
    iprot.readStructEnd()
12136 
 
12137 
  def write(self, oprot):
12138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12140 
      return
12141 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12142 
    if self.success is not None:
12143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12144 
      oprot.writeBool(self.success)
12145 
      oprot.writeFieldEnd()
12146 
    if self.ex is not None:
12147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12148 
      self.ex.write(oprot)
12149 
      oprot.writeFieldEnd()
12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
2536 chandransh 12168 
class requestPickupNumber_args:
12169 
  """
12170 
  Attributes:
12171 
   - orderId
4579 rajveer 12172 
   - providerId
2536 chandransh 12173 
  """
12174 
 
12175 
  thrift_spec = (
12176 
    None, # 0
12177 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12178 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12179 
  )
12180 
 
4579 rajveer 12181 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12182 
    self.orderId = orderId
4579 rajveer 12183 
    self.providerId = providerId
2536 chandransh 12184 
 
12185 
  def read(self, iprot):
12186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12188 
      return
12189 
    iprot.readStructBegin()
12190 
    while True:
12191 
      (fname, ftype, fid) = iprot.readFieldBegin()
12192 
      if ftype == TType.STOP:
12193 
        break
12194 
      if fid == 1:
12195 
        if ftype == TType.I64:
12196 
          self.orderId = iprot.readI64();
12197 
        else:
12198 
          iprot.skip(ftype)
4579 rajveer 12199 
      elif fid == 2:
12200 
        if ftype == TType.I64:
12201 
          self.providerId = iprot.readI64();
12202 
        else:
12203 
          iprot.skip(ftype)
2536 chandransh 12204 
      else:
12205 
        iprot.skip(ftype)
12206 
      iprot.readFieldEnd()
12207 
    iprot.readStructEnd()
12208 
 
12209 
  def write(self, oprot):
12210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12212 
      return
12213 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12214 
    if self.orderId is not None:
2536 chandransh 12215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12216 
      oprot.writeI64(self.orderId)
12217 
      oprot.writeFieldEnd()
4579 rajveer 12218 
    if self.providerId is not None:
12219 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12220 
      oprot.writeI64(self.providerId)
12221 
      oprot.writeFieldEnd()
2536 chandransh 12222 
    oprot.writeFieldStop()
12223 
    oprot.writeStructEnd()
12224 
 
3431 rajveer 12225 
  def validate(self):
12226 
    return
12227 
 
12228 
 
2536 chandransh 12229 
  def __repr__(self):
12230 
    L = ['%s=%r' % (key, value)
12231 
      for key, value in self.__dict__.iteritems()]
12232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12233 
 
12234 
  def __eq__(self, other):
12235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12236 
 
12237 
  def __ne__(self, other):
12238 
    return not (self == other)
12239 
 
12240 
class requestPickupNumber_result:
12241 
  """
12242 
  Attributes:
12243 
   - success
12244 
   - ex
12245 
  """
12246 
 
12247 
  thrift_spec = (
12248 
    (0, TType.BOOL, 'success', None, None, ), # 0
12249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12250 
  )
12251 
 
12252 
  def __init__(self, success=None, ex=None,):
12253 
    self.success = success
12254 
    self.ex = ex
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 0:
12266 
        if ftype == TType.BOOL:
12267 
          self.success = iprot.readBool();
12268 
        else:
12269 
          iprot.skip(ftype)
12270 
      elif fid == 1:
12271 
        if ftype == TType.STRUCT:
12272 
          self.ex = TransactionServiceException()
12273 
          self.ex.read(iprot)
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      else:
12277 
        iprot.skip(ftype)
12278 
      iprot.readFieldEnd()
12279 
    iprot.readStructEnd()
12280 
 
12281 
  def write(self, oprot):
12282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12284 
      return
12285 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12286 
    if self.success is not None:
2536 chandransh 12287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12288 
      oprot.writeBool(self.success)
12289 
      oprot.writeFieldEnd()
3431 rajveer 12290 
    if self.ex is not None:
2536 chandransh 12291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12292 
      self.ex.write(oprot)
12293 
      oprot.writeFieldEnd()
12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
3431 rajveer 12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
2536 chandransh 12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
12312 
class authorizePickup_args:
12313 
  """
12314 
  Attributes:
12315 
   - orderId
12316 
   - pickupNumber
4602 rajveer 12317 
   - providerId
2536 chandransh 12318 
  """
12319 
 
12320 
  thrift_spec = (
12321 
    None, # 0
12322 
    (1, TType.I64, 'orderId', None, None, ), # 1
12323 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12324 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12325 
  )
12326 
 
4602 rajveer 12327 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12328 
    self.orderId = orderId
12329 
    self.pickupNumber = pickupNumber
4602 rajveer 12330 
    self.providerId = providerId
2536 chandransh 12331 
 
12332 
  def read(self, iprot):
12333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12335 
      return
12336 
    iprot.readStructBegin()
12337 
    while True:
12338 
      (fname, ftype, fid) = iprot.readFieldBegin()
12339 
      if ftype == TType.STOP:
12340 
        break
12341 
      if fid == 1:
12342 
        if ftype == TType.I64:
12343 
          self.orderId = iprot.readI64();
12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      elif fid == 2:
12347 
        if ftype == TType.STRING:
12348 
          self.pickupNumber = iprot.readString();
12349 
        else:
12350 
          iprot.skip(ftype)
4602 rajveer 12351 
      elif fid == 3:
12352 
        if ftype == TType.I64:
12353 
          self.providerId = iprot.readI64();
12354 
        else:
12355 
          iprot.skip(ftype)
2536 chandransh 12356 
      else:
12357 
        iprot.skip(ftype)
12358 
      iprot.readFieldEnd()
12359 
    iprot.readStructEnd()
12360 
 
12361 
  def write(self, oprot):
12362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12364 
      return
12365 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12366 
    if self.orderId is not None:
2536 chandransh 12367 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12368 
      oprot.writeI64(self.orderId)
12369 
      oprot.writeFieldEnd()
3431 rajveer 12370 
    if self.pickupNumber is not None:
2536 chandransh 12371 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12372 
      oprot.writeString(self.pickupNumber)
12373 
      oprot.writeFieldEnd()
4602 rajveer 12374 
    if self.providerId is not None:
12375 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12376 
      oprot.writeI64(self.providerId)
12377 
      oprot.writeFieldEnd()
2536 chandransh 12378 
    oprot.writeFieldStop()
12379 
    oprot.writeStructEnd()
12380 
 
3431 rajveer 12381 
  def validate(self):
12382 
    return
12383 
 
12384 
 
2536 chandransh 12385 
  def __repr__(self):
12386 
    L = ['%s=%r' % (key, value)
12387 
      for key, value in self.__dict__.iteritems()]
12388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12389 
 
12390 
  def __eq__(self, other):
12391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12392 
 
12393 
  def __ne__(self, other):
12394 
    return not (self == other)
12395 
 
12396 
class authorizePickup_result:
12397 
  """
12398 
  Attributes:
12399 
   - success
12400 
   - ex
12401 
  """
12402 
 
12403 
  thrift_spec = (
12404 
    (0, TType.BOOL, 'success', None, None, ), # 0
12405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12406 
  )
12407 
 
12408 
  def __init__(self, success=None, ex=None,):
12409 
    self.success = success
12410 
    self.ex = ex
12411 
 
12412 
  def read(self, iprot):
12413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12415 
      return
12416 
    iprot.readStructBegin()
12417 
    while True:
12418 
      (fname, ftype, fid) = iprot.readFieldBegin()
12419 
      if ftype == TType.STOP:
12420 
        break
12421 
      if fid == 0:
12422 
        if ftype == TType.BOOL:
12423 
          self.success = iprot.readBool();
12424 
        else:
12425 
          iprot.skip(ftype)
12426 
      elif fid == 1:
12427 
        if ftype == TType.STRUCT:
12428 
          self.ex = TransactionServiceException()
12429 
          self.ex.read(iprot)
12430 
        else:
12431 
          iprot.skip(ftype)
12432 
      else:
12433 
        iprot.skip(ftype)
12434 
      iprot.readFieldEnd()
12435 
    iprot.readStructEnd()
12436 
 
12437 
  def write(self, oprot):
12438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12440 
      return
12441 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12442 
    if self.success is not None:
2536 chandransh 12443 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12444 
      oprot.writeBool(self.success)
12445 
      oprot.writeFieldEnd()
3431 rajveer 12446 
    if self.ex is not None:
2536 chandransh 12447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12448 
      self.ex.write(oprot)
12449 
      oprot.writeFieldEnd()
12450 
    oprot.writeFieldStop()
12451 
    oprot.writeStructEnd()
12452 
 
3431 rajveer 12453 
  def validate(self):
12454 
    return
12455 
 
12456 
 
2536 chandransh 12457 
  def __repr__(self):
12458 
    L = ['%s=%r' % (key, value)
12459 
      for key, value in self.__dict__.iteritems()]
12460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12461 
 
12462 
  def __eq__(self, other):
12463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12464 
 
12465 
  def __ne__(self, other):
12466 
    return not (self == other)
12467 
 
2764 chandransh 12468 
class markDoasAsPickedUp_args:
12469 
  """
12470 
  Attributes:
12471 
   - providerId
12472 
   - pickupDetails
12473 
  """
12474 
 
12475 
  thrift_spec = (
12476 
    None, # 0
12477 
    (1, TType.I64, 'providerId', None, None, ), # 1
12478 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12479 
  )
12480 
 
12481 
  def __init__(self, providerId=None, pickupDetails=None,):
12482 
    self.providerId = providerId
12483 
    self.pickupDetails = pickupDetails
12484 
 
12485 
  def read(self, iprot):
12486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12488 
      return
12489 
    iprot.readStructBegin()
12490 
    while True:
12491 
      (fname, ftype, fid) = iprot.readFieldBegin()
12492 
      if ftype == TType.STOP:
12493 
        break
12494 
      if fid == 1:
12495 
        if ftype == TType.I64:
12496 
          self.providerId = iprot.readI64();
12497 
        else:
12498 
          iprot.skip(ftype)
12499 
      elif fid == 2:
12500 
        if ftype == TType.MAP:
12501 
          self.pickupDetails = {}
4581 phani.kuma 12502 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12503 
          for _i201 in xrange(_size197):
12504 
            _key202 = iprot.readString();
12505 
            _val203 = iprot.readString();
12506 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12507 
          iprot.readMapEnd()
12508 
        else:
12509 
          iprot.skip(ftype)
12510 
      else:
12511 
        iprot.skip(ftype)
12512 
      iprot.readFieldEnd()
12513 
    iprot.readStructEnd()
12514 
 
12515 
  def write(self, oprot):
12516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12518 
      return
12519 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12520 
    if self.providerId is not None:
2764 chandransh 12521 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12522 
      oprot.writeI64(self.providerId)
12523 
      oprot.writeFieldEnd()
3431 rajveer 12524 
    if self.pickupDetails is not None:
2764 chandransh 12525 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12526 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12527 
      for kiter204,viter205 in self.pickupDetails.items():
12528 
        oprot.writeString(kiter204)
12529 
        oprot.writeString(viter205)
2764 chandransh 12530 
      oprot.writeMapEnd()
12531 
      oprot.writeFieldEnd()
12532 
    oprot.writeFieldStop()
12533 
    oprot.writeStructEnd()
12534 
 
3431 rajveer 12535 
  def validate(self):
12536 
    return
12537 
 
12538 
 
2764 chandransh 12539 
  def __repr__(self):
12540 
    L = ['%s=%r' % (key, value)
12541 
      for key, value in self.__dict__.iteritems()]
12542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12543 
 
12544 
  def __eq__(self, other):
12545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12546 
 
12547 
  def __ne__(self, other):
12548 
    return not (self == other)
12549 
 
12550 
class markDoasAsPickedUp_result:
12551 
  """
12552 
  Attributes:
12553 
   - success
12554 
  """
12555 
 
12556 
  thrift_spec = (
12557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12558 
  )
12559 
 
12560 
  def __init__(self, success=None,):
12561 
    self.success = success
12562 
 
12563 
  def read(self, iprot):
12564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12566 
      return
12567 
    iprot.readStructBegin()
12568 
    while True:
12569 
      (fname, ftype, fid) = iprot.readFieldBegin()
12570 
      if ftype == TType.STOP:
12571 
        break
12572 
      if fid == 0:
12573 
        if ftype == TType.LIST:
12574 
          self.success = []
4581 phani.kuma 12575 
          (_etype209, _size206) = iprot.readListBegin()
12576 
          for _i210 in xrange(_size206):
12577 
            _elem211 = Order()
12578 
            _elem211.read(iprot)
12579 
            self.success.append(_elem211)
2764 chandransh 12580 
          iprot.readListEnd()
12581 
        else:
12582 
          iprot.skip(ftype)
12583 
      else:
12584 
        iprot.skip(ftype)
12585 
      iprot.readFieldEnd()
12586 
    iprot.readStructEnd()
12587 
 
12588 
  def write(self, oprot):
12589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12591 
      return
12592 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12593 
    if self.success is not None:
2764 chandransh 12594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12596 
      for iter212 in self.success:
12597 
        iter212.write(oprot)
2764 chandransh 12598 
      oprot.writeListEnd()
12599 
      oprot.writeFieldEnd()
12600 
    oprot.writeFieldStop()
12601 
    oprot.writeStructEnd()
12602 
 
3431 rajveer 12603 
  def validate(self):
12604 
    return
12605 
 
12606 
 
2764 chandransh 12607 
  def __repr__(self):
12608 
    L = ['%s=%r' % (key, value)
12609 
      for key, value in self.__dict__.iteritems()]
12610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12611 
 
12612 
  def __eq__(self, other):
12613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12614 
 
12615 
  def __ne__(self, other):
12616 
    return not (self == other)
12617 
 
2616 chandransh 12618 
class receiveReturn_args:
2591 chandransh 12619 
  """
12620 
  Attributes:
12621 
   - orderId
4479 rajveer 12622 
   - receiveCondition
2591 chandransh 12623 
  """
2536 chandransh 12624 
 
2591 chandransh 12625 
  thrift_spec = (
12626 
    None, # 0
12627 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12628 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12629 
  )
12630 
 
4479 rajveer 12631 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12632 
    self.orderId = orderId
4479 rajveer 12633 
    self.receiveCondition = receiveCondition
2591 chandransh 12634 
 
12635 
  def read(self, iprot):
12636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12638 
      return
12639 
    iprot.readStructBegin()
12640 
    while True:
12641 
      (fname, ftype, fid) = iprot.readFieldBegin()
12642 
      if ftype == TType.STOP:
12643 
        break
12644 
      if fid == 1:
12645 
        if ftype == TType.I64:
12646 
          self.orderId = iprot.readI64();
12647 
        else:
12648 
          iprot.skip(ftype)
4479 rajveer 12649 
      elif fid == 2:
12650 
        if ftype == TType.I64:
12651 
          self.receiveCondition = iprot.readI64();
12652 
        else:
12653 
          iprot.skip(ftype)
2591 chandransh 12654 
      else:
12655 
        iprot.skip(ftype)
12656 
      iprot.readFieldEnd()
12657 
    iprot.readStructEnd()
12658 
 
12659 
  def write(self, oprot):
12660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12662 
      return
2616 chandransh 12663 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12664 
    if self.orderId is not None:
2591 chandransh 12665 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12666 
      oprot.writeI64(self.orderId)
12667 
      oprot.writeFieldEnd()
4479 rajveer 12668 
    if self.receiveCondition is not None:
12669 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12670 
      oprot.writeI64(self.receiveCondition)
12671 
      oprot.writeFieldEnd()
2591 chandransh 12672 
    oprot.writeFieldStop()
12673 
    oprot.writeStructEnd()
12674 
 
3431 rajveer 12675 
  def validate(self):
12676 
    return
12677 
 
12678 
 
2591 chandransh 12679 
  def __repr__(self):
12680 
    L = ['%s=%r' % (key, value)
12681 
      for key, value in self.__dict__.iteritems()]
12682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12683 
 
12684 
  def __eq__(self, other):
12685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12686 
 
12687 
  def __ne__(self, other):
12688 
    return not (self == other)
12689 
 
2616 chandransh 12690 
class receiveReturn_result:
2591 chandransh 12691 
  """
12692 
  Attributes:
12693 
   - success
12694 
   - ex
12695 
  """
12696 
 
12697 
  thrift_spec = (
12698 
    (0, TType.BOOL, 'success', None, None, ), # 0
12699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12700 
  )
12701 
 
12702 
  def __init__(self, success=None, ex=None,):
12703 
    self.success = success
12704 
    self.ex = ex
12705 
 
12706 
  def read(self, iprot):
12707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12709 
      return
12710 
    iprot.readStructBegin()
12711 
    while True:
12712 
      (fname, ftype, fid) = iprot.readFieldBegin()
12713 
      if ftype == TType.STOP:
12714 
        break
12715 
      if fid == 0:
12716 
        if ftype == TType.BOOL:
12717 
          self.success = iprot.readBool();
12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      elif fid == 1:
12721 
        if ftype == TType.STRUCT:
12722 
          self.ex = TransactionServiceException()
12723 
          self.ex.read(iprot)
12724 
        else:
12725 
          iprot.skip(ftype)
12726 
      else:
12727 
        iprot.skip(ftype)
12728 
      iprot.readFieldEnd()
12729 
    iprot.readStructEnd()
12730 
 
12731 
  def write(self, oprot):
12732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12734 
      return
2616 chandransh 12735 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12736 
    if self.success is not None:
2591 chandransh 12737 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12738 
      oprot.writeBool(self.success)
12739 
      oprot.writeFieldEnd()
3431 rajveer 12740 
    if self.ex is not None:
2591 chandransh 12741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12742 
      self.ex.write(oprot)
12743 
      oprot.writeFieldEnd()
12744 
    oprot.writeFieldStop()
12745 
    oprot.writeStructEnd()
12746 
 
3431 rajveer 12747 
  def validate(self):
12748 
    return
12749 
 
12750 
 
2591 chandransh 12751 
  def __repr__(self):
12752 
    L = ['%s=%r' % (key, value)
12753 
      for key, value in self.__dict__.iteritems()]
12754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12755 
 
12756 
  def __eq__(self, other):
12757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12758 
 
12759 
  def __ne__(self, other):
12760 
    return not (self == other)
12761 
 
12762 
class validateDoa_args:
12763 
  """
12764 
  Attributes:
12765 
   - orderId
12766 
   - isValid
12767 
  """
12768 
 
12769 
  thrift_spec = (
12770 
    None, # 0
12771 
    (1, TType.I64, 'orderId', None, None, ), # 1
12772 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12773 
  )
12774 
 
12775 
  def __init__(self, orderId=None, isValid=None,):
12776 
    self.orderId = orderId
12777 
    self.isValid = isValid
12778 
 
12779 
  def read(self, iprot):
12780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12782 
      return
12783 
    iprot.readStructBegin()
12784 
    while True:
12785 
      (fname, ftype, fid) = iprot.readFieldBegin()
12786 
      if ftype == TType.STOP:
12787 
        break
12788 
      if fid == 1:
12789 
        if ftype == TType.I64:
12790 
          self.orderId = iprot.readI64();
12791 
        else:
12792 
          iprot.skip(ftype)
12793 
      elif fid == 2:
12794 
        if ftype == TType.BOOL:
12795 
          self.isValid = iprot.readBool();
12796 
        else:
12797 
          iprot.skip(ftype)
12798 
      else:
12799 
        iprot.skip(ftype)
12800 
      iprot.readFieldEnd()
12801 
    iprot.readStructEnd()
12802 
 
12803 
  def write(self, oprot):
12804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12806 
      return
12807 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12808 
    if self.orderId is not None:
2591 chandransh 12809 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12810 
      oprot.writeI64(self.orderId)
12811 
      oprot.writeFieldEnd()
3431 rajveer 12812 
    if self.isValid is not None:
2591 chandransh 12813 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12814 
      oprot.writeBool(self.isValid)
12815 
      oprot.writeFieldEnd()
12816 
    oprot.writeFieldStop()
12817 
    oprot.writeStructEnd()
12818 
 
3431 rajveer 12819 
  def validate(self):
12820 
    return
12821 
 
12822 
 
2591 chandransh 12823 
  def __repr__(self):
12824 
    L = ['%s=%r' % (key, value)
12825 
      for key, value in self.__dict__.iteritems()]
12826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12827 
 
12828 
  def __eq__(self, other):
12829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12830 
 
12831 
  def __ne__(self, other):
12832 
    return not (self == other)
12833 
 
12834 
class validateDoa_result:
12835 
  """
12836 
  Attributes:
12837 
   - success
12838 
   - ex
12839 
  """
12840 
 
12841 
  thrift_spec = (
12842 
    (0, TType.BOOL, 'success', None, None, ), # 0
12843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12844 
  )
12845 
 
12846 
  def __init__(self, success=None, ex=None,):
12847 
    self.success = success
12848 
    self.ex = ex
12849 
 
12850 
  def read(self, iprot):
12851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12853 
      return
12854 
    iprot.readStructBegin()
12855 
    while True:
12856 
      (fname, ftype, fid) = iprot.readFieldBegin()
12857 
      if ftype == TType.STOP:
12858 
        break
12859 
      if fid == 0:
12860 
        if ftype == TType.BOOL:
12861 
          self.success = iprot.readBool();
12862 
        else:
12863 
          iprot.skip(ftype)
12864 
      elif fid == 1:
12865 
        if ftype == TType.STRUCT:
12866 
          self.ex = TransactionServiceException()
12867 
          self.ex.read(iprot)
12868 
        else:
12869 
          iprot.skip(ftype)
12870 
      else:
12871 
        iprot.skip(ftype)
12872 
      iprot.readFieldEnd()
12873 
    iprot.readStructEnd()
12874 
 
12875 
  def write(self, oprot):
12876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12878 
      return
12879 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12880 
    if self.success is not None:
2591 chandransh 12881 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12882 
      oprot.writeBool(self.success)
12883 
      oprot.writeFieldEnd()
3431 rajveer 12884 
    if self.ex is not None:
2591 chandransh 12885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12886 
      self.ex.write(oprot)
12887 
      oprot.writeFieldEnd()
12888 
    oprot.writeFieldStop()
12889 
    oprot.writeStructEnd()
12890 
 
3431 rajveer 12891 
  def validate(self):
12892 
    return
12893 
 
12894 
 
2591 chandransh 12895 
  def __repr__(self):
12896 
    L = ['%s=%r' % (key, value)
12897 
      for key, value in self.__dict__.iteritems()]
12898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12899 
 
12900 
  def __eq__(self, other):
12901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12902 
 
12903 
  def __ne__(self, other):
12904 
    return not (self == other)
12905 
 
4495 rajveer 12906 
class validateReturnProduct_args:
12907 
  """
12908 
  Attributes:
12909 
   - orderId
12910 
   - isUsable
12911 
  """
12912 
 
12913 
  thrift_spec = (
12914 
    None, # 0
12915 
    (1, TType.I64, 'orderId', None, None, ), # 1
12916 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12917 
  )
12918 
 
12919 
  def __init__(self, orderId=None, isUsable=None,):
12920 
    self.orderId = orderId
12921 
    self.isUsable = isUsable
12922 
 
12923 
  def read(self, iprot):
12924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12926 
      return
12927 
    iprot.readStructBegin()
12928 
    while True:
12929 
      (fname, ftype, fid) = iprot.readFieldBegin()
12930 
      if ftype == TType.STOP:
12931 
        break
12932 
      if fid == 1:
12933 
        if ftype == TType.I64:
12934 
          self.orderId = iprot.readI64();
12935 
        else:
12936 
          iprot.skip(ftype)
12937 
      elif fid == 2:
12938 
        if ftype == TType.BOOL:
12939 
          self.isUsable = iprot.readBool();
12940 
        else:
12941 
          iprot.skip(ftype)
12942 
      else:
12943 
        iprot.skip(ftype)
12944 
      iprot.readFieldEnd()
12945 
    iprot.readStructEnd()
12946 
 
12947 
  def write(self, oprot):
12948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12950 
      return
12951 
    oprot.writeStructBegin('validateReturnProduct_args')
12952 
    if self.orderId is not None:
12953 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12954 
      oprot.writeI64(self.orderId)
12955 
      oprot.writeFieldEnd()
12956 
    if self.isUsable is not None:
12957 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12958 
      oprot.writeBool(self.isUsable)
12959 
      oprot.writeFieldEnd()
12960 
    oprot.writeFieldStop()
12961 
    oprot.writeStructEnd()
12962 
 
12963 
  def validate(self):
12964 
    return
12965 
 
12966 
 
12967 
  def __repr__(self):
12968 
    L = ['%s=%r' % (key, value)
12969 
      for key, value in self.__dict__.iteritems()]
12970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12971 
 
12972 
  def __eq__(self, other):
12973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12974 
 
12975 
  def __ne__(self, other):
12976 
    return not (self == other)
12977 
 
12978 
class validateReturnProduct_result:
12979 
  """
12980 
  Attributes:
12981 
   - success
12982 
   - ex
12983 
  """
12984 
 
12985 
  thrift_spec = (
12986 
    (0, TType.BOOL, 'success', None, None, ), # 0
12987 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12988 
  )
12989 
 
12990 
  def __init__(self, success=None, ex=None,):
12991 
    self.success = success
12992 
    self.ex = ex
12993 
 
12994 
  def read(self, iprot):
12995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12997 
      return
12998 
    iprot.readStructBegin()
12999 
    while True:
13000 
      (fname, ftype, fid) = iprot.readFieldBegin()
13001 
      if ftype == TType.STOP:
13002 
        break
13003 
      if fid == 0:
13004 
        if ftype == TType.BOOL:
13005 
          self.success = iprot.readBool();
13006 
        else:
13007 
          iprot.skip(ftype)
13008 
      elif fid == 1:
13009 
        if ftype == TType.STRUCT:
13010 
          self.ex = TransactionServiceException()
13011 
          self.ex.read(iprot)
13012 
        else:
13013 
          iprot.skip(ftype)
13014 
      else:
13015 
        iprot.skip(ftype)
13016 
      iprot.readFieldEnd()
13017 
    iprot.readStructEnd()
13018 
 
13019 
  def write(self, oprot):
13020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13022 
      return
13023 
    oprot.writeStructBegin('validateReturnProduct_result')
13024 
    if self.success is not None:
13025 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13026 
      oprot.writeBool(self.success)
13027 
      oprot.writeFieldEnd()
13028 
    if self.ex is not None:
13029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13030 
      self.ex.write(oprot)
13031 
      oprot.writeFieldEnd()
13032 
    oprot.writeFieldStop()
13033 
    oprot.writeStructEnd()
13034 
 
13035 
  def validate(self):
13036 
    return
13037 
 
13038 
 
13039 
  def __repr__(self):
13040 
    L = ['%s=%r' % (key, value)
13041 
      for key, value in self.__dict__.iteritems()]
13042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13043 
 
13044 
  def __eq__(self, other):
13045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13046 
 
13047 
  def __ne__(self, other):
13048 
    return not (self == other)
13049 
 
2616 chandransh 13050 
class reshipOrder_args:
13051 
  """
13052 
  Attributes:
13053 
   - orderId
13054 
  """
2591 chandransh 13055 
 
2616 chandransh 13056 
  thrift_spec = (
13057 
    None, # 0
13058 
    (1, TType.I64, 'orderId', None, None, ), # 1
13059 
  )
13060 
 
13061 
  def __init__(self, orderId=None,):
13062 
    self.orderId = orderId
13063 
 
13064 
  def read(self, iprot):
13065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13067 
      return
13068 
    iprot.readStructBegin()
13069 
    while True:
13070 
      (fname, ftype, fid) = iprot.readFieldBegin()
13071 
      if ftype == TType.STOP:
13072 
        break
13073 
      if fid == 1:
13074 
        if ftype == TType.I64:
13075 
          self.orderId = iprot.readI64();
13076 
        else:
13077 
          iprot.skip(ftype)
13078 
      else:
13079 
        iprot.skip(ftype)
13080 
      iprot.readFieldEnd()
13081 
    iprot.readStructEnd()
13082 
 
13083 
  def write(self, oprot):
13084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13086 
      return
13087 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13088 
    if self.orderId is not None:
2616 chandransh 13089 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13090 
      oprot.writeI64(self.orderId)
13091 
      oprot.writeFieldEnd()
13092 
    oprot.writeFieldStop()
13093 
    oprot.writeStructEnd()
13094 
 
3431 rajveer 13095 
  def validate(self):
13096 
    return
13097 
 
13098 
 
2616 chandransh 13099 
  def __repr__(self):
13100 
    L = ['%s=%r' % (key, value)
13101 
      for key, value in self.__dict__.iteritems()]
13102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13103 
 
13104 
  def __eq__(self, other):
13105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13106 
 
13107 
  def __ne__(self, other):
13108 
    return not (self == other)
13109 
 
13110 
class reshipOrder_result:
13111 
  """
13112 
  Attributes:
13113 
   - success
13114 
   - ex
13115 
  """
13116 
 
13117 
  thrift_spec = (
13118 
    (0, TType.I64, 'success', None, None, ), # 0
13119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13120 
  )
13121 
 
13122 
  def __init__(self, success=None, ex=None,):
13123 
    self.success = success
13124 
    self.ex = ex
13125 
 
13126 
  def read(self, iprot):
13127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13129 
      return
13130 
    iprot.readStructBegin()
13131 
    while True:
13132 
      (fname, ftype, fid) = iprot.readFieldBegin()
13133 
      if ftype == TType.STOP:
13134 
        break
13135 
      if fid == 0:
13136 
        if ftype == TType.I64:
13137 
          self.success = iprot.readI64();
13138 
        else:
13139 
          iprot.skip(ftype)
13140 
      elif fid == 1:
13141 
        if ftype == TType.STRUCT:
13142 
          self.ex = TransactionServiceException()
13143 
          self.ex.read(iprot)
13144 
        else:
13145 
          iprot.skip(ftype)
13146 
      else:
13147 
        iprot.skip(ftype)
13148 
      iprot.readFieldEnd()
13149 
    iprot.readStructEnd()
13150 
 
13151 
  def write(self, oprot):
13152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13154 
      return
13155 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13156 
    if self.success is not None:
2616 chandransh 13157 
      oprot.writeFieldBegin('success', TType.I64, 0)
13158 
      oprot.writeI64(self.success)
13159 
      oprot.writeFieldEnd()
3431 rajveer 13160 
    if self.ex is not None:
2616 chandransh 13161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13162 
      self.ex.write(oprot)
13163 
      oprot.writeFieldEnd()
13164 
    oprot.writeFieldStop()
13165 
    oprot.writeStructEnd()
13166 
 
3431 rajveer 13167 
  def validate(self):
13168 
    return
13169 
 
13170 
 
2616 chandransh 13171 
  def __repr__(self):
13172 
    L = ['%s=%r' % (key, value)
13173 
      for key, value in self.__dict__.iteritems()]
13174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13175 
 
13176 
  def __eq__(self, other):
13177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13178 
 
13179 
  def __ne__(self, other):
13180 
    return not (self == other)
13181 
 
13182 
class refundOrder_args:
13183 
  """
13184 
  Attributes:
13185 
   - orderId
3226 chandransh 13186 
   - refundedBy
13187 
   - reason
2616 chandransh 13188 
  """
13189 
 
13190 
  thrift_spec = (
13191 
    None, # 0
13192 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13193 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13194 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13195 
  )
13196 
 
3226 chandransh 13197 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13198 
    self.orderId = orderId
3226 chandransh 13199 
    self.refundedBy = refundedBy
13200 
    self.reason = reason
2616 chandransh 13201 
 
13202 
  def read(self, iprot):
13203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13205 
      return
13206 
    iprot.readStructBegin()
13207 
    while True:
13208 
      (fname, ftype, fid) = iprot.readFieldBegin()
13209 
      if ftype == TType.STOP:
13210 
        break
13211 
      if fid == 1:
13212 
        if ftype == TType.I64:
13213 
          self.orderId = iprot.readI64();
13214 
        else:
13215 
          iprot.skip(ftype)
3226 chandransh 13216 
      elif fid == 2:
13217 
        if ftype == TType.STRING:
13218 
          self.refundedBy = iprot.readString();
13219 
        else:
13220 
          iprot.skip(ftype)
13221 
      elif fid == 3:
13222 
        if ftype == TType.STRING:
13223 
          self.reason = iprot.readString();
13224 
        else:
13225 
          iprot.skip(ftype)
2616 chandransh 13226 
      else:
13227 
        iprot.skip(ftype)
13228 
      iprot.readFieldEnd()
13229 
    iprot.readStructEnd()
13230 
 
13231 
  def write(self, oprot):
13232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13234 
      return
13235 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13236 
    if self.orderId is not None:
2616 chandransh 13237 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13238 
      oprot.writeI64(self.orderId)
13239 
      oprot.writeFieldEnd()
3431 rajveer 13240 
    if self.refundedBy is not None:
3226 chandransh 13241 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13242 
      oprot.writeString(self.refundedBy)
13243 
      oprot.writeFieldEnd()
3431 rajveer 13244 
    if self.reason is not None:
3226 chandransh 13245 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13246 
      oprot.writeString(self.reason)
13247 
      oprot.writeFieldEnd()
2616 chandransh 13248 
    oprot.writeFieldStop()
13249 
    oprot.writeStructEnd()
13250 
 
3431 rajveer 13251 
  def validate(self):
13252 
    return
13253 
 
13254 
 
2616 chandransh 13255 
  def __repr__(self):
13256 
    L = ['%s=%r' % (key, value)
13257 
      for key, value in self.__dict__.iteritems()]
13258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13259 
 
13260 
  def __eq__(self, other):
13261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13262 
 
13263 
  def __ne__(self, other):
13264 
    return not (self == other)
13265 
 
13266 
class refundOrder_result:
13267 
  """
13268 
  Attributes:
13269 
   - success
13270 
   - ex
13271 
  """
13272 
 
13273 
  thrift_spec = (
13274 
    (0, TType.BOOL, 'success', None, None, ), # 0
13275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13276 
  )
13277 
 
13278 
  def __init__(self, success=None, ex=None,):
13279 
    self.success = success
13280 
    self.ex = ex
13281 
 
13282 
  def read(self, iprot):
13283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13285 
      return
13286 
    iprot.readStructBegin()
13287 
    while True:
13288 
      (fname, ftype, fid) = iprot.readFieldBegin()
13289 
      if ftype == TType.STOP:
13290 
        break
13291 
      if fid == 0:
13292 
        if ftype == TType.BOOL:
13293 
          self.success = iprot.readBool();
13294 
        else:
13295 
          iprot.skip(ftype)
13296 
      elif fid == 1:
13297 
        if ftype == TType.STRUCT:
13298 
          self.ex = TransactionServiceException()
13299 
          self.ex.read(iprot)
13300 
        else:
13301 
          iprot.skip(ftype)
13302 
      else:
13303 
        iprot.skip(ftype)
13304 
      iprot.readFieldEnd()
13305 
    iprot.readStructEnd()
13306 
 
13307 
  def write(self, oprot):
13308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13310 
      return
13311 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13312 
    if self.success is not None:
2616 chandransh 13313 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13314 
      oprot.writeBool(self.success)
13315 
      oprot.writeFieldEnd()
3431 rajveer 13316 
    if self.ex is not None:
2616 chandransh 13317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13318 
      self.ex.write(oprot)
13319 
      oprot.writeFieldEnd()
13320 
    oprot.writeFieldStop()
13321 
    oprot.writeStructEnd()
13322 
 
3431 rajveer 13323 
  def validate(self):
13324 
    return
13325 
 
13326 
 
2616 chandransh 13327 
  def __repr__(self):
13328 
    L = ['%s=%r' % (key, value)
13329 
      for key, value in self.__dict__.iteritems()]
13330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13331 
 
13332 
  def __eq__(self, other):
13333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13334 
 
13335 
  def __ne__(self, other):
13336 
    return not (self == other)
13337 
 
2690 chandransh 13338 
class getReturnOrders_args:
13339 
  """
13340 
  Attributes:
13341 
   - warehouseId
13342 
   - fromDate
13343 
   - toDate
13344 
  """
2616 chandransh 13345 
 
2690 chandransh 13346 
  thrift_spec = (
13347 
    None, # 0
13348 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13349 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13350 
    (3, TType.I64, 'toDate', None, None, ), # 3
13351 
  )
13352 
 
13353 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13354 
    self.warehouseId = warehouseId
13355 
    self.fromDate = fromDate
13356 
    self.toDate = toDate
13357 
 
13358 
  def read(self, iprot):
13359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13361 
      return
13362 
    iprot.readStructBegin()
13363 
    while True:
13364 
      (fname, ftype, fid) = iprot.readFieldBegin()
13365 
      if ftype == TType.STOP:
13366 
        break
13367 
      if fid == 1:
13368 
        if ftype == TType.I64:
13369 
          self.warehouseId = iprot.readI64();
13370 
        else:
13371 
          iprot.skip(ftype)
13372 
      elif fid == 2:
13373 
        if ftype == TType.I64:
13374 
          self.fromDate = iprot.readI64();
13375 
        else:
13376 
          iprot.skip(ftype)
13377 
      elif fid == 3:
13378 
        if ftype == TType.I64:
13379 
          self.toDate = iprot.readI64();
13380 
        else:
13381 
          iprot.skip(ftype)
13382 
      else:
13383 
        iprot.skip(ftype)
13384 
      iprot.readFieldEnd()
13385 
    iprot.readStructEnd()
13386 
 
13387 
  def write(self, oprot):
13388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13390 
      return
13391 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13392 
    if self.warehouseId is not None:
2690 chandransh 13393 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13394 
      oprot.writeI64(self.warehouseId)
13395 
      oprot.writeFieldEnd()
3431 rajveer 13396 
    if self.fromDate is not None:
2690 chandransh 13397 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13398 
      oprot.writeI64(self.fromDate)
13399 
      oprot.writeFieldEnd()
3431 rajveer 13400 
    if self.toDate is not None:
2690 chandransh 13401 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13402 
      oprot.writeI64(self.toDate)
13403 
      oprot.writeFieldEnd()
13404 
    oprot.writeFieldStop()
13405 
    oprot.writeStructEnd()
13406 
 
3431 rajveer 13407 
  def validate(self):
13408 
    return
13409 
 
13410 
 
2690 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 getReturnOrders_result:
13423 
  """
13424 
  Attributes:
13425 
   - success
13426 
  """
13427 
 
13428 
  thrift_spec = (
13429 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13430 
  )
13431 
 
13432 
  def __init__(self, success=None,):
13433 
    self.success = success
13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 0:
13445 
        if ftype == TType.LIST:
13446 
          self.success = []
4581 phani.kuma 13447 
          (_etype216, _size213) = iprot.readListBegin()
13448 
          for _i217 in xrange(_size213):
13449 
            _elem218 = ReturnOrder()
13450 
            _elem218.read(iprot)
13451 
            self.success.append(_elem218)
2690 chandransh 13452 
          iprot.readListEnd()
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      else:
13456 
        iprot.skip(ftype)
13457 
      iprot.readFieldEnd()
13458 
    iprot.readStructEnd()
13459 
 
13460 
  def write(self, oprot):
13461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13463 
      return
13464 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13465 
    if self.success is not None:
2690 chandransh 13466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13468 
      for iter219 in self.success:
13469 
        iter219.write(oprot)
2690 chandransh 13470 
      oprot.writeListEnd()
13471 
      oprot.writeFieldEnd()
13472 
    oprot.writeFieldStop()
13473 
    oprot.writeStructEnd()
13474 
 
3431 rajveer 13475 
  def validate(self):
13476 
    return
13477 
 
13478 
 
2690 chandransh 13479 
  def __repr__(self):
13480 
    L = ['%s=%r' % (key, value)
13481 
      for key, value in self.__dict__.iteritems()]
13482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13483 
 
13484 
  def __eq__(self, other):
13485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13486 
 
13487 
  def __ne__(self, other):
13488 
    return not (self == other)
13489 
 
2700 chandransh 13490 
class getReturnOrder_args:
13491 
  """
13492 
  Attributes:
13493 
   - id
13494 
  """
13495 
 
13496 
  thrift_spec = (
13497 
    None, # 0
13498 
    (1, TType.I64, 'id', None, None, ), # 1
13499 
  )
13500 
 
13501 
  def __init__(self, id=None,):
13502 
    self.id = id
13503 
 
13504 
  def read(self, iprot):
13505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13507 
      return
13508 
    iprot.readStructBegin()
13509 
    while True:
13510 
      (fname, ftype, fid) = iprot.readFieldBegin()
13511 
      if ftype == TType.STOP:
13512 
        break
13513 
      if fid == 1:
13514 
        if ftype == TType.I64:
13515 
          self.id = iprot.readI64();
13516 
        else:
13517 
          iprot.skip(ftype)
13518 
      else:
13519 
        iprot.skip(ftype)
13520 
      iprot.readFieldEnd()
13521 
    iprot.readStructEnd()
13522 
 
13523 
  def write(self, oprot):
13524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13526 
      return
13527 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13528 
    if self.id is not None:
2700 chandransh 13529 
      oprot.writeFieldBegin('id', TType.I64, 1)
13530 
      oprot.writeI64(self.id)
13531 
      oprot.writeFieldEnd()
13532 
    oprot.writeFieldStop()
13533 
    oprot.writeStructEnd()
13534 
 
3431 rajveer 13535 
  def validate(self):
13536 
    return
13537 
 
13538 
 
2700 chandransh 13539 
  def __repr__(self):
13540 
    L = ['%s=%r' % (key, value)
13541 
      for key, value in self.__dict__.iteritems()]
13542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13543 
 
13544 
  def __eq__(self, other):
13545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13546 
 
13547 
  def __ne__(self, other):
13548 
    return not (self == other)
13549 
 
13550 
class getReturnOrder_result:
13551 
  """
13552 
  Attributes:
13553 
   - success
13554 
   - ex
13555 
  """
13556 
 
13557 
  thrift_spec = (
13558 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13559 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13560 
  )
13561 
 
13562 
  def __init__(self, success=None, ex=None,):
13563 
    self.success = success
13564 
    self.ex = ex
13565 
 
13566 
  def read(self, iprot):
13567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13569 
      return
13570 
    iprot.readStructBegin()
13571 
    while True:
13572 
      (fname, ftype, fid) = iprot.readFieldBegin()
13573 
      if ftype == TType.STOP:
13574 
        break
13575 
      if fid == 0:
13576 
        if ftype == TType.STRUCT:
13577 
          self.success = ReturnOrder()
13578 
          self.success.read(iprot)
13579 
        else:
13580 
          iprot.skip(ftype)
13581 
      elif fid == 1:
13582 
        if ftype == TType.STRUCT:
13583 
          self.ex = TransactionServiceException()
13584 
          self.ex.read(iprot)
13585 
        else:
13586 
          iprot.skip(ftype)
13587 
      else:
13588 
        iprot.skip(ftype)
13589 
      iprot.readFieldEnd()
13590 
    iprot.readStructEnd()
13591 
 
13592 
  def write(self, oprot):
13593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13595 
      return
13596 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13597 
    if self.success is not None:
2700 chandransh 13598 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13599 
      self.success.write(oprot)
13600 
      oprot.writeFieldEnd()
3431 rajveer 13601 
    if self.ex is not None:
2700 chandransh 13602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13603 
      self.ex.write(oprot)
13604 
      oprot.writeFieldEnd()
13605 
    oprot.writeFieldStop()
13606 
    oprot.writeStructEnd()
13607 
 
3431 rajveer 13608 
  def validate(self):
13609 
    return
13610 
 
13611 
 
2700 chandransh 13612 
  def __repr__(self):
13613 
    L = ['%s=%r' % (key, value)
13614 
      for key, value in self.__dict__.iteritems()]
13615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13616 
 
13617 
  def __eq__(self, other):
13618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13619 
 
13620 
  def __ne__(self, other):
13621 
    return not (self == other)
13622 
 
2690 chandransh 13623 
class processReturn_args:
13624 
  """
13625 
  Attributes:
13626 
   - returnOrderId
13627 
  """
13628 
 
13629 
  thrift_spec = (
13630 
    None, # 0
13631 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13632 
  )
13633 
 
13634 
  def __init__(self, returnOrderId=None,):
13635 
    self.returnOrderId = returnOrderId
13636 
 
13637 
  def read(self, iprot):
13638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13640 
      return
13641 
    iprot.readStructBegin()
13642 
    while True:
13643 
      (fname, ftype, fid) = iprot.readFieldBegin()
13644 
      if ftype == TType.STOP:
13645 
        break
13646 
      if fid == 1:
13647 
        if ftype == TType.I64:
13648 
          self.returnOrderId = iprot.readI64();
13649 
        else:
13650 
          iprot.skip(ftype)
13651 
      else:
13652 
        iprot.skip(ftype)
13653 
      iprot.readFieldEnd()
13654 
    iprot.readStructEnd()
13655 
 
13656 
  def write(self, oprot):
13657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13659 
      return
13660 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13661 
    if self.returnOrderId is not None:
2690 chandransh 13662 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13663 
      oprot.writeI64(self.returnOrderId)
13664 
      oprot.writeFieldEnd()
13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
3431 rajveer 13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
2690 chandransh 13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
13683 
class processReturn_result:
13684 
  """
13685 
  Attributes:
13686 
   - ex
13687 
  """
13688 
 
13689 
  thrift_spec = (
13690 
    None, # 0
13691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13692 
  )
13693 
 
13694 
  def __init__(self, ex=None,):
13695 
    self.ex = ex
13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
13706 
      if fid == 1:
13707 
        if ftype == TType.STRUCT:
13708 
          self.ex = TransactionServiceException()
13709 
          self.ex.read(iprot)
13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      else:
13713 
        iprot.skip(ftype)
13714 
      iprot.readFieldEnd()
13715 
    iprot.readStructEnd()
13716 
 
13717 
  def write(self, oprot):
13718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13720 
      return
13721 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13722 
    if self.ex is not None:
2690 chandransh 13723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13724 
      self.ex.write(oprot)
13725 
      oprot.writeFieldEnd()
13726 
    oprot.writeFieldStop()
13727 
    oprot.writeStructEnd()
13728 
 
3431 rajveer 13729 
  def validate(self):
13730 
    return
13731 
 
13732 
 
2690 chandransh 13733 
  def __repr__(self):
13734 
    L = ['%s=%r' % (key, value)
13735 
      for key, value in self.__dict__.iteritems()]
13736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13737 
 
13738 
  def __eq__(self, other):
13739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13740 
 
13741 
  def __ne__(self, other):
13742 
    return not (self == other)
13743 
 
2819 chandransh 13744 
class createPurchaseOrder_args:
13745 
  """
13746 
  Attributes:
13747 
   - warehouseId
13748 
  """
2690 chandransh 13749 
 
2819 chandransh 13750 
  thrift_spec = (
13751 
    None, # 0
13752 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13753 
  )
13754 
 
13755 
  def __init__(self, warehouseId=None,):
13756 
    self.warehouseId = warehouseId
13757 
 
13758 
  def read(self, iprot):
13759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13761 
      return
13762 
    iprot.readStructBegin()
13763 
    while True:
13764 
      (fname, ftype, fid) = iprot.readFieldBegin()
13765 
      if ftype == TType.STOP:
13766 
        break
13767 
      if fid == 1:
13768 
        if ftype == TType.I64:
13769 
          self.warehouseId = iprot.readI64();
13770 
        else:
13771 
          iprot.skip(ftype)
13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
13781 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13782 
    if self.warehouseId is not None:
2819 chandransh 13783 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13784 
      oprot.writeI64(self.warehouseId)
13785 
      oprot.writeFieldEnd()
13786 
    oprot.writeFieldStop()
13787 
    oprot.writeStructEnd()
13788 
 
3431 rajveer 13789 
  def validate(self):
13790 
    return
13791 
 
13792 
 
2819 chandransh 13793 
  def __repr__(self):
13794 
    L = ['%s=%r' % (key, value)
13795 
      for key, value in self.__dict__.iteritems()]
13796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13797 
 
13798 
  def __eq__(self, other):
13799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13800 
 
13801 
  def __ne__(self, other):
13802 
    return not (self == other)
13803 
 
13804 
class createPurchaseOrder_result:
13805 
  """
13806 
  Attributes:
13807 
   - success
13808 
   - ex
13809 
  """
13810 
 
13811 
  thrift_spec = (
4586 mandeep.dh 13812 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13813 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13814 
  )
13815 
 
13816 
  def __init__(self, success=None, ex=None,):
13817 
    self.success = success
13818 
    self.ex = ex
13819 
 
13820 
  def read(self, iprot):
13821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13823 
      return
13824 
    iprot.readStructBegin()
13825 
    while True:
13826 
      (fname, ftype, fid) = iprot.readFieldBegin()
13827 
      if ftype == TType.STOP:
13828 
        break
13829 
      if fid == 0:
4586 mandeep.dh 13830 
        if ftype == TType.LIST:
13831 
          self.success = []
13832 
          (_etype223, _size220) = iprot.readListBegin()
13833 
          for _i224 in xrange(_size220):
13834 
            _elem225 = iprot.readI64();
13835 
            self.success.append(_elem225)
13836 
          iprot.readListEnd()
2819 chandransh 13837 
        else:
13838 
          iprot.skip(ftype)
13839 
      elif fid == 1:
13840 
        if ftype == TType.STRUCT:
13841 
          self.ex = TransactionServiceException()
13842 
          self.ex.read(iprot)
13843 
        else:
13844 
          iprot.skip(ftype)
13845 
      else:
13846 
        iprot.skip(ftype)
13847 
      iprot.readFieldEnd()
13848 
    iprot.readStructEnd()
13849 
 
13850 
  def write(self, oprot):
13851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13853 
      return
13854 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13855 
    if self.success is not None:
4586 mandeep.dh 13856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13857 
      oprot.writeListBegin(TType.I64, len(self.success))
13858 
      for iter226 in self.success:
13859 
        oprot.writeI64(iter226)
13860 
      oprot.writeListEnd()
2819 chandransh 13861 
      oprot.writeFieldEnd()
3431 rajveer 13862 
    if self.ex is not None:
2819 chandransh 13863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13864 
      self.ex.write(oprot)
13865 
      oprot.writeFieldEnd()
13866 
    oprot.writeFieldStop()
13867 
    oprot.writeStructEnd()
13868 
 
3431 rajveer 13869 
  def validate(self):
13870 
    return
13871 
 
13872 
 
2819 chandransh 13873 
  def __repr__(self):
13874 
    L = ['%s=%r' % (key, value)
13875 
      for key, value in self.__dict__.iteritems()]
13876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13877 
 
13878 
  def __eq__(self, other):
13879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13880 
 
13881 
  def __ne__(self, other):
13882 
    return not (self == other)
3451 chandransh 13883 
 
13884 
class updateWeight_args:
13885 
  """
13886 
  Attributes:
13887 
   - orderId
13888 
   - weight
13889 
  """
13890 
 
13891 
  thrift_spec = (
13892 
    None, # 0
13893 
    (1, TType.I64, 'orderId', None, None, ), # 1
13894 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13895 
  )
13896 
 
13897 
  def __init__(self, orderId=None, weight=None,):
13898 
    self.orderId = orderId
13899 
    self.weight = weight
13900 
 
13901 
  def read(self, iprot):
13902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13904 
      return
13905 
    iprot.readStructBegin()
13906 
    while True:
13907 
      (fname, ftype, fid) = iprot.readFieldBegin()
13908 
      if ftype == TType.STOP:
13909 
        break
13910 
      if fid == 1:
13911 
        if ftype == TType.I64:
13912 
          self.orderId = iprot.readI64();
13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      elif fid == 2:
13916 
        if ftype == TType.DOUBLE:
13917 
          self.weight = iprot.readDouble();
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
13929 
    oprot.writeStructBegin('updateWeight_args')
13930 
    if self.orderId is not None:
13931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13932 
      oprot.writeI64(self.orderId)
13933 
      oprot.writeFieldEnd()
13934 
    if self.weight is not None:
13935 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13936 
      oprot.writeDouble(self.weight)
13937 
      oprot.writeFieldEnd()
13938 
    oprot.writeFieldStop()
13939 
    oprot.writeStructEnd()
13940 
 
13941 
  def validate(self):
13942 
    return
13943 
 
13944 
 
13945 
  def __repr__(self):
13946 
    L = ['%s=%r' % (key, value)
13947 
      for key, value in self.__dict__.iteritems()]
13948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13949 
 
13950 
  def __eq__(self, other):
13951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13952 
 
13953 
  def __ne__(self, other):
13954 
    return not (self == other)
13955 
 
13956 
class updateWeight_result:
13957 
  """
13958 
  Attributes:
13959 
   - success
13960 
   - ex
13961 
  """
13962 
 
13963 
  thrift_spec = (
13964 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13966 
  )
13967 
 
13968 
  def __init__(self, success=None, ex=None,):
13969 
    self.success = success
13970 
    self.ex = ex
13971 
 
13972 
  def read(self, iprot):
13973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13975 
      return
13976 
    iprot.readStructBegin()
13977 
    while True:
13978 
      (fname, ftype, fid) = iprot.readFieldBegin()
13979 
      if ftype == TType.STOP:
13980 
        break
13981 
      if fid == 0:
13982 
        if ftype == TType.STRUCT:
13983 
          self.success = Order()
13984 
          self.success.read(iprot)
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      elif fid == 1:
13988 
        if ftype == TType.STRUCT:
13989 
          self.ex = TransactionServiceException()
13990 
          self.ex.read(iprot)
13991 
        else:
13992 
          iprot.skip(ftype)
13993 
      else:
13994 
        iprot.skip(ftype)
13995 
      iprot.readFieldEnd()
13996 
    iprot.readStructEnd()
13997 
 
13998 
  def write(self, oprot):
13999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14001 
      return
14002 
    oprot.writeStructBegin('updateWeight_result')
14003 
    if self.success is not None:
14004 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14005 
      self.success.write(oprot)
14006 
      oprot.writeFieldEnd()
14007 
    if self.ex is not None:
14008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14009 
      self.ex.write(oprot)
14010 
      oprot.writeFieldEnd()
14011 
    oprot.writeFieldStop()
14012 
    oprot.writeStructEnd()
14013 
 
14014 
  def validate(self):
14015 
    return
14016 
 
14017 
 
14018 
  def __repr__(self):
14019 
    L = ['%s=%r' % (key, value)
14020 
      for key, value in self.__dict__.iteritems()]
14021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14022 
 
14023 
  def __eq__(self, other):
14024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14025 
 
14026 
  def __ne__(self, other):
14027 
    return not (self == other)
3469 chandransh 14028 
 
14029 
class changeItem_args:
14030 
  """
14031 
  Attributes:
14032 
   - orderId
14033 
   - itemId
14034 
  """
14035 
 
14036 
  thrift_spec = (
14037 
    None, # 0
14038 
    (1, TType.I64, 'orderId', None, None, ), # 1
14039 
    (2, TType.I64, 'itemId', None, None, ), # 2
14040 
  )
14041 
 
14042 
  def __init__(self, orderId=None, itemId=None,):
14043 
    self.orderId = orderId
14044 
    self.itemId = itemId
14045 
 
14046 
  def read(self, iprot):
14047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14049 
      return
14050 
    iprot.readStructBegin()
14051 
    while True:
14052 
      (fname, ftype, fid) = iprot.readFieldBegin()
14053 
      if ftype == TType.STOP:
14054 
        break
14055 
      if fid == 1:
14056 
        if ftype == TType.I64:
14057 
          self.orderId = iprot.readI64();
14058 
        else:
14059 
          iprot.skip(ftype)
14060 
      elif fid == 2:
14061 
        if ftype == TType.I64:
14062 
          self.itemId = iprot.readI64();
14063 
        else:
14064 
          iprot.skip(ftype)
14065 
      else:
14066 
        iprot.skip(ftype)
14067 
      iprot.readFieldEnd()
14068 
    iprot.readStructEnd()
14069 
 
14070 
  def write(self, oprot):
14071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14073 
      return
14074 
    oprot.writeStructBegin('changeItem_args')
14075 
    if self.orderId is not None:
14076 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14077 
      oprot.writeI64(self.orderId)
14078 
      oprot.writeFieldEnd()
14079 
    if self.itemId is not None:
14080 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14081 
      oprot.writeI64(self.itemId)
14082 
      oprot.writeFieldEnd()
14083 
    oprot.writeFieldStop()
14084 
    oprot.writeStructEnd()
14085 
 
14086 
  def validate(self):
14087 
    return
14088 
 
14089 
 
14090 
  def __repr__(self):
14091 
    L = ['%s=%r' % (key, value)
14092 
      for key, value in self.__dict__.iteritems()]
14093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14094 
 
14095 
  def __eq__(self, other):
14096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14097 
 
14098 
  def __ne__(self, other):
14099 
    return not (self == other)
14100 
 
14101 
class changeItem_result:
14102 
  """
14103 
  Attributes:
14104 
   - success
14105 
   - ex
14106 
  """
14107 
 
14108 
  thrift_spec = (
14109 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14111 
  )
14112 
 
14113 
  def __init__(self, success=None, ex=None,):
14114 
    self.success = success
14115 
    self.ex = ex
14116 
 
14117 
  def read(self, iprot):
14118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14120 
      return
14121 
    iprot.readStructBegin()
14122 
    while True:
14123 
      (fname, ftype, fid) = iprot.readFieldBegin()
14124 
      if ftype == TType.STOP:
14125 
        break
14126 
      if fid == 0:
14127 
        if ftype == TType.STRUCT:
14128 
          self.success = Order()
14129 
          self.success.read(iprot)
14130 
        else:
14131 
          iprot.skip(ftype)
14132 
      elif fid == 1:
14133 
        if ftype == TType.STRUCT:
14134 
          self.ex = TransactionServiceException()
14135 
          self.ex.read(iprot)
14136 
        else:
14137 
          iprot.skip(ftype)
14138 
      else:
14139 
        iprot.skip(ftype)
14140 
      iprot.readFieldEnd()
14141 
    iprot.readStructEnd()
14142 
 
14143 
  def write(self, oprot):
14144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14146 
      return
14147 
    oprot.writeStructBegin('changeItem_result')
14148 
    if self.success is not None:
14149 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14150 
      self.success.write(oprot)
14151 
      oprot.writeFieldEnd()
14152 
    if self.ex is not None:
14153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14154 
      self.ex.write(oprot)
14155 
      oprot.writeFieldEnd()
14156 
    oprot.writeFieldStop()
14157 
    oprot.writeStructEnd()
14158 
 
14159 
  def validate(self):
14160 
    return
14161 
 
14162 
 
14163 
  def __repr__(self):
14164 
    L = ['%s=%r' % (key, value)
14165 
      for key, value in self.__dict__.iteritems()]
14166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14167 
 
14168 
  def __eq__(self, other):
14169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14170 
 
14171 
  def __ne__(self, other):
14172 
    return not (self == other)
14173 
 
14174 
class shiftToWarehouse_args:
14175 
  """
14176 
  Attributes:
14177 
   - orderId
14178 
   - warehouseId
14179 
  """
14180 
 
14181 
  thrift_spec = (
14182 
    None, # 0
14183 
    (1, TType.I64, 'orderId', None, None, ), # 1
14184 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14185 
  )
14186 
 
14187 
  def __init__(self, orderId=None, warehouseId=None,):
14188 
    self.orderId = orderId
14189 
    self.warehouseId = warehouseId
14190 
 
14191 
  def read(self, iprot):
14192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14194 
      return
14195 
    iprot.readStructBegin()
14196 
    while True:
14197 
      (fname, ftype, fid) = iprot.readFieldBegin()
14198 
      if ftype == TType.STOP:
14199 
        break
14200 
      if fid == 1:
14201 
        if ftype == TType.I64:
14202 
          self.orderId = iprot.readI64();
14203 
        else:
14204 
          iprot.skip(ftype)
14205 
      elif fid == 2:
14206 
        if ftype == TType.I64:
14207 
          self.warehouseId = iprot.readI64();
14208 
        else:
14209 
          iprot.skip(ftype)
14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
14219 
    oprot.writeStructBegin('shiftToWarehouse_args')
14220 
    if self.orderId is not None:
14221 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14222 
      oprot.writeI64(self.orderId)
14223 
      oprot.writeFieldEnd()
14224 
    if self.warehouseId is not None:
14225 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14226 
      oprot.writeI64(self.warehouseId)
14227 
      oprot.writeFieldEnd()
14228 
    oprot.writeFieldStop()
14229 
    oprot.writeStructEnd()
14230 
 
14231 
  def validate(self):
14232 
    return
14233 
 
14234 
 
14235 
  def __repr__(self):
14236 
    L = ['%s=%r' % (key, value)
14237 
      for key, value in self.__dict__.iteritems()]
14238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14239 
 
14240 
  def __eq__(self, other):
14241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14242 
 
14243 
  def __ne__(self, other):
14244 
    return not (self == other)
14245 
 
14246 
class shiftToWarehouse_result:
14247 
  """
14248 
  Attributes:
14249 
   - success
14250 
   - ex
14251 
  """
14252 
 
14253 
  thrift_spec = (
14254 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14256 
  )
14257 
 
14258 
  def __init__(self, success=None, ex=None,):
14259 
    self.success = success
14260 
    self.ex = ex
14261 
 
14262 
  def read(self, iprot):
14263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14265 
      return
14266 
    iprot.readStructBegin()
14267 
    while True:
14268 
      (fname, ftype, fid) = iprot.readFieldBegin()
14269 
      if ftype == TType.STOP:
14270 
        break
14271 
      if fid == 0:
14272 
        if ftype == TType.STRUCT:
14273 
          self.success = Order()
14274 
          self.success.read(iprot)
14275 
        else:
14276 
          iprot.skip(ftype)
14277 
      elif fid == 1:
14278 
        if ftype == TType.STRUCT:
14279 
          self.ex = TransactionServiceException()
14280 
          self.ex.read(iprot)
14281 
        else:
14282 
          iprot.skip(ftype)
14283 
      else:
14284 
        iprot.skip(ftype)
14285 
      iprot.readFieldEnd()
14286 
    iprot.readStructEnd()
14287 
 
14288 
  def write(self, oprot):
14289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14291 
      return
14292 
    oprot.writeStructBegin('shiftToWarehouse_result')
14293 
    if self.success is not None:
14294 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14295 
      self.success.write(oprot)
14296 
      oprot.writeFieldEnd()
14297 
    if self.ex is not None:
14298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14299 
      self.ex.write(oprot)
14300 
      oprot.writeFieldEnd()
14301 
    oprot.writeFieldStop()
14302 
    oprot.writeStructEnd()
14303 
 
14304 
  def validate(self):
14305 
    return
14306 
 
14307 
 
14308 
  def __repr__(self):
14309 
    L = ['%s=%r' % (key, value)
14310 
      for key, value in self.__dict__.iteritems()]
14311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14312 
 
14313 
  def __eq__(self, other):
14314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14315 
 
14316 
  def __ne__(self, other):
14317 
    return not (self == other)
3553 chandransh 14318 
 
14319 
class addDelayReason_args:
14320 
  """
14321 
  Attributes:
14322 
   - orderId
14323 
   - delayReason
3986 chandransh 14324 
   - furtherDelay
4647 rajveer 14325 
   - delayReasonText
3553 chandransh 14326 
  """
14327 
 
14328 
  thrift_spec = (
14329 
    None, # 0
14330 
    (1, TType.I64, 'orderId', None, None, ), # 1
14331 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14332 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14333 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14334 
  )
14335 
 
4647 rajveer 14336 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14337 
    self.orderId = orderId
14338 
    self.delayReason = delayReason
3986 chandransh 14339 
    self.furtherDelay = furtherDelay
4647 rajveer 14340 
    self.delayReasonText = delayReasonText
3553 chandransh 14341 
 
14342 
  def read(self, iprot):
14343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14345 
      return
14346 
    iprot.readStructBegin()
14347 
    while True:
14348 
      (fname, ftype, fid) = iprot.readFieldBegin()
14349 
      if ftype == TType.STOP:
14350 
        break
14351 
      if fid == 1:
14352 
        if ftype == TType.I64:
14353 
          self.orderId = iprot.readI64();
14354 
        else:
14355 
          iprot.skip(ftype)
14356 
      elif fid == 2:
14357 
        if ftype == TType.I32:
14358 
          self.delayReason = iprot.readI32();
14359 
        else:
14360 
          iprot.skip(ftype)
3986 chandransh 14361 
      elif fid == 3:
14362 
        if ftype == TType.I64:
14363 
          self.furtherDelay = iprot.readI64();
14364 
        else:
14365 
          iprot.skip(ftype)
4647 rajveer 14366 
      elif fid == 4:
14367 
        if ftype == TType.STRING:
14368 
          self.delayReasonText = iprot.readString();
14369 
        else:
14370 
          iprot.skip(ftype)
3553 chandransh 14371 
      else:
14372 
        iprot.skip(ftype)
14373 
      iprot.readFieldEnd()
14374 
    iprot.readStructEnd()
14375 
 
14376 
  def write(self, oprot):
14377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14379 
      return
14380 
    oprot.writeStructBegin('addDelayReason_args')
14381 
    if self.orderId is not None:
14382 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14383 
      oprot.writeI64(self.orderId)
14384 
      oprot.writeFieldEnd()
14385 
    if self.delayReason is not None:
14386 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14387 
      oprot.writeI32(self.delayReason)
14388 
      oprot.writeFieldEnd()
3986 chandransh 14389 
    if self.furtherDelay is not None:
14390 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14391 
      oprot.writeI64(self.furtherDelay)
14392 
      oprot.writeFieldEnd()
4647 rajveer 14393 
    if self.delayReasonText is not None:
14394 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14395 
      oprot.writeString(self.delayReasonText)
14396 
      oprot.writeFieldEnd()
3553 chandransh 14397 
    oprot.writeFieldStop()
14398 
    oprot.writeStructEnd()
14399 
 
14400 
  def validate(self):
14401 
    return
14402 
 
14403 
 
14404 
  def __repr__(self):
14405 
    L = ['%s=%r' % (key, value)
14406 
      for key, value in self.__dict__.iteritems()]
14407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14408 
 
14409 
  def __eq__(self, other):
14410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14411 
 
14412 
  def __ne__(self, other):
14413 
    return not (self == other)
14414 
 
14415 
class addDelayReason_result:
14416 
  """
14417 
  Attributes:
14418 
   - success
14419 
   - ex
14420 
  """
14421 
 
14422 
  thrift_spec = (
14423 
    (0, TType.BOOL, 'success', None, None, ), # 0
14424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14425 
  )
14426 
 
14427 
  def __init__(self, success=None, ex=None,):
14428 
    self.success = success
14429 
    self.ex = ex
14430 
 
14431 
  def read(self, iprot):
14432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14434 
      return
14435 
    iprot.readStructBegin()
14436 
    while True:
14437 
      (fname, ftype, fid) = iprot.readFieldBegin()
14438 
      if ftype == TType.STOP:
14439 
        break
14440 
      if fid == 0:
14441 
        if ftype == TType.BOOL:
14442 
          self.success = iprot.readBool();
14443 
        else:
14444 
          iprot.skip(ftype)
14445 
      elif fid == 1:
14446 
        if ftype == TType.STRUCT:
14447 
          self.ex = TransactionServiceException()
14448 
          self.ex.read(iprot)
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      else:
14452 
        iprot.skip(ftype)
14453 
      iprot.readFieldEnd()
14454 
    iprot.readStructEnd()
14455 
 
14456 
  def write(self, oprot):
14457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14459 
      return
14460 
    oprot.writeStructBegin('addDelayReason_result')
14461 
    if self.success is not None:
14462 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14463 
      oprot.writeBool(self.success)
14464 
      oprot.writeFieldEnd()
14465 
    if self.ex is not None:
14466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14467 
      self.ex.write(oprot)
14468 
      oprot.writeFieldEnd()
14469 
    oprot.writeFieldStop()
14470 
    oprot.writeStructEnd()
14471 
 
14472 
  def validate(self):
14473 
    return
14474 
 
14475 
 
14476 
  def __repr__(self):
14477 
    L = ['%s=%r' % (key, value)
14478 
      for key, value in self.__dict__.iteritems()]
14479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14480 
 
14481 
  def __eq__(self, other):
14482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14483 
 
14484 
  def __ne__(self, other):
14485 
    return not (self == other)
3956 chandransh 14486 
 
14487 
class reconcileCodCollection_args:
14488 
  """
14489 
  Attributes:
14490 
   - collectedAmountMap
14491 
   - xferBy
14492 
   - xferTxnId
14493 
   - xferDate
14494 
  """
14495 
 
14496 
  thrift_spec = (
14497 
    None, # 0
14498 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14499 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14500 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14501 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14502 
  )
14503 
 
14504 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14505 
    self.collectedAmountMap = collectedAmountMap
14506 
    self.xferBy = xferBy
14507 
    self.xferTxnId = xferTxnId
14508 
    self.xferDate = xferDate
14509 
 
14510 
  def read(self, iprot):
14511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14513 
      return
14514 
    iprot.readStructBegin()
14515 
    while True:
14516 
      (fname, ftype, fid) = iprot.readFieldBegin()
14517 
      if ftype == TType.STOP:
14518 
        break
14519 
      if fid == 1:
14520 
        if ftype == TType.MAP:
14521 
          self.collectedAmountMap = {}
4586 mandeep.dh 14522 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14523 
          for _i231 in xrange(_size227):
14524 
            _key232 = iprot.readString();
14525 
            _val233 = iprot.readDouble();
14526 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14527 
          iprot.readMapEnd()
14528 
        else:
14529 
          iprot.skip(ftype)
14530 
      elif fid == 2:
14531 
        if ftype == TType.STRING:
14532 
          self.xferBy = iprot.readString();
14533 
        else:
14534 
          iprot.skip(ftype)
14535 
      elif fid == 3:
14536 
        if ftype == TType.STRING:
14537 
          self.xferTxnId = iprot.readString();
14538 
        else:
14539 
          iprot.skip(ftype)
14540 
      elif fid == 4:
14541 
        if ftype == TType.I64:
14542 
          self.xferDate = iprot.readI64();
14543 
        else:
14544 
          iprot.skip(ftype)
14545 
      else:
14546 
        iprot.skip(ftype)
14547 
      iprot.readFieldEnd()
14548 
    iprot.readStructEnd()
14549 
 
14550 
  def write(self, oprot):
14551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14553 
      return
14554 
    oprot.writeStructBegin('reconcileCodCollection_args')
14555 
    if self.collectedAmountMap is not None:
14556 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14557 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14558 
      for kiter234,viter235 in self.collectedAmountMap.items():
14559 
        oprot.writeString(kiter234)
14560 
        oprot.writeDouble(viter235)
3956 chandransh 14561 
      oprot.writeMapEnd()
14562 
      oprot.writeFieldEnd()
14563 
    if self.xferBy is not None:
14564 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14565 
      oprot.writeString(self.xferBy)
14566 
      oprot.writeFieldEnd()
14567 
    if self.xferTxnId is not None:
14568 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14569 
      oprot.writeString(self.xferTxnId)
14570 
      oprot.writeFieldEnd()
14571 
    if self.xferDate is not None:
14572 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14573 
      oprot.writeI64(self.xferDate)
14574 
      oprot.writeFieldEnd()
14575 
    oprot.writeFieldStop()
14576 
    oprot.writeStructEnd()
14577 
 
14578 
  def validate(self):
14579 
    return
14580 
 
14581 
 
14582 
  def __repr__(self):
14583 
    L = ['%s=%r' % (key, value)
14584 
      for key, value in self.__dict__.iteritems()]
14585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14586 
 
14587 
  def __eq__(self, other):
14588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14589 
 
14590 
  def __ne__(self, other):
14591 
    return not (self == other)
14592 
 
14593 
class reconcileCodCollection_result:
14594 
  """
14595 
  Attributes:
14596 
   - success
14597 
   - ex
14598 
  """
14599 
 
14600 
  thrift_spec = (
14601 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14603 
  )
14604 
 
14605 
  def __init__(self, success=None, ex=None,):
14606 
    self.success = success
14607 
    self.ex = ex
14608 
 
14609 
  def read(self, iprot):
14610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14612 
      return
14613 
    iprot.readStructBegin()
14614 
    while True:
14615 
      (fname, ftype, fid) = iprot.readFieldBegin()
14616 
      if ftype == TType.STOP:
14617 
        break
14618 
      if fid == 0:
14619 
        if ftype == TType.MAP:
14620 
          self.success = {}
4586 mandeep.dh 14621 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14622 
          for _i240 in xrange(_size236):
14623 
            _key241 = iprot.readString();
14624 
            _val242 = iprot.readString();
14625 
            self.success[_key241] = _val242
3956 chandransh 14626 
          iprot.readMapEnd()
14627 
        else:
14628 
          iprot.skip(ftype)
14629 
      elif fid == 1:
14630 
        if ftype == TType.STRUCT:
14631 
          self.ex = TransactionServiceException()
14632 
          self.ex.read(iprot)
14633 
        else:
14634 
          iprot.skip(ftype)
14635 
      else:
14636 
        iprot.skip(ftype)
14637 
      iprot.readFieldEnd()
14638 
    iprot.readStructEnd()
14639 
 
14640 
  def write(self, oprot):
14641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14643 
      return
14644 
    oprot.writeStructBegin('reconcileCodCollection_result')
14645 
    if self.success is not None:
14646 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14647 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14648 
      for kiter243,viter244 in self.success.items():
14649 
        oprot.writeString(kiter243)
14650 
        oprot.writeString(viter244)
3956 chandransh 14651 
      oprot.writeMapEnd()
14652 
      oprot.writeFieldEnd()
14653 
    if self.ex is not None:
14654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14655 
      self.ex.write(oprot)
14656 
      oprot.writeFieldEnd()
14657 
    oprot.writeFieldStop()
14658 
    oprot.writeStructEnd()
14659 
 
14660 
  def validate(self):
14661 
    return
14662 
 
14663 
 
14664 
  def __repr__(self):
14665 
    L = ['%s=%r' % (key, value)
14666 
      for key, value in self.__dict__.iteritems()]
14667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14668 
 
14669 
  def __eq__(self, other):
14670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14671 
 
14672 
  def __ne__(self, other):
14673 
    return not (self == other)
4008 mandeep.dh 14674 
 
14675 
class getTransactionsRequiringExtraProcessing_args:
14676 
  """
14677 
  Attributes:
14678 
   - category
14679 
  """
14680 
 
14681 
  thrift_spec = (
14682 
    None, # 0
14683 
    (1, TType.I32, 'category', None, None, ), # 1
14684 
  )
14685 
 
14686 
  def __init__(self, category=None,):
14687 
    self.category = category
14688 
 
14689 
  def read(self, iprot):
14690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14692 
      return
14693 
    iprot.readStructBegin()
14694 
    while True:
14695 
      (fname, ftype, fid) = iprot.readFieldBegin()
14696 
      if ftype == TType.STOP:
14697 
        break
14698 
      if fid == 1:
14699 
        if ftype == TType.I32:
14700 
          self.category = iprot.readI32();
14701 
        else:
14702 
          iprot.skip(ftype)
14703 
      else:
14704 
        iprot.skip(ftype)
14705 
      iprot.readFieldEnd()
14706 
    iprot.readStructEnd()
14707 
 
14708 
  def write(self, oprot):
14709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14711 
      return
14712 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14713 
    if self.category is not None:
14714 
      oprot.writeFieldBegin('category', TType.I32, 1)
14715 
      oprot.writeI32(self.category)
14716 
      oprot.writeFieldEnd()
14717 
    oprot.writeFieldStop()
14718 
    oprot.writeStructEnd()
14719 
 
14720 
  def validate(self):
14721 
    return
14722 
 
14723 
 
14724 
  def __repr__(self):
14725 
    L = ['%s=%r' % (key, value)
14726 
      for key, value in self.__dict__.iteritems()]
14727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14728 
 
14729 
  def __eq__(self, other):
14730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14731 
 
14732 
  def __ne__(self, other):
14733 
    return not (self == other)
14734 
 
14735 
class getTransactionsRequiringExtraProcessing_result:
14736 
  """
14737 
  Attributes:
14738 
   - success
14739 
  """
14740 
 
14741 
  thrift_spec = (
14742 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14743 
  )
14744 
 
14745 
  def __init__(self, success=None,):
14746 
    self.success = success
14747 
 
14748 
  def read(self, iprot):
14749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14751 
      return
14752 
    iprot.readStructBegin()
14753 
    while True:
14754 
      (fname, ftype, fid) = iprot.readFieldBegin()
14755 
      if ftype == TType.STOP:
14756 
        break
14757 
      if fid == 0:
14758 
        if ftype == TType.LIST:
14759 
          self.success = []
4586 mandeep.dh 14760 
          (_etype248, _size245) = iprot.readListBegin()
14761 
          for _i249 in xrange(_size245):
14762 
            _elem250 = iprot.readI64();
14763 
            self.success.append(_elem250)
4008 mandeep.dh 14764 
          iprot.readListEnd()
14765 
        else:
14766 
          iprot.skip(ftype)
14767 
      else:
14768 
        iprot.skip(ftype)
14769 
      iprot.readFieldEnd()
14770 
    iprot.readStructEnd()
14771 
 
14772 
  def write(self, oprot):
14773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14775 
      return
14776 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14777 
    if self.success is not None:
14778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14779 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14780 
      for iter251 in self.success:
14781 
        oprot.writeI64(iter251)
4008 mandeep.dh 14782 
      oprot.writeListEnd()
14783 
      oprot.writeFieldEnd()
14784 
    oprot.writeFieldStop()
14785 
    oprot.writeStructEnd()
14786 
 
14787 
  def validate(self):
14788 
    return
14789 
 
14790 
 
14791 
  def __repr__(self):
14792 
    L = ['%s=%r' % (key, value)
14793 
      for key, value in self.__dict__.iteritems()]
14794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14795 
 
14796 
  def __eq__(self, other):
14797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14798 
 
14799 
  def __ne__(self, other):
14800 
    return not (self == other)
14801 
 
14802 
class markTransactionAsProcessed_args:
14803 
  """
14804 
  Attributes:
14805 
   - transactionId
14806 
   - category
14807 
  """
14808 
 
14809 
  thrift_spec = (
14810 
    None, # 0
14811 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14812 
    (2, TType.I32, 'category', None, None, ), # 2
14813 
  )
14814 
 
14815 
  def __init__(self, transactionId=None, category=None,):
14816 
    self.transactionId = transactionId
14817 
    self.category = category
14818 
 
14819 
  def read(self, iprot):
14820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14822 
      return
14823 
    iprot.readStructBegin()
14824 
    while True:
14825 
      (fname, ftype, fid) = iprot.readFieldBegin()
14826 
      if ftype == TType.STOP:
14827 
        break
14828 
      if fid == 1:
14829 
        if ftype == TType.I64:
14830 
          self.transactionId = iprot.readI64();
14831 
        else:
14832 
          iprot.skip(ftype)
14833 
      elif fid == 2:
14834 
        if ftype == TType.I32:
14835 
          self.category = iprot.readI32();
14836 
        else:
14837 
          iprot.skip(ftype)
14838 
      else:
14839 
        iprot.skip(ftype)
14840 
      iprot.readFieldEnd()
14841 
    iprot.readStructEnd()
14842 
 
14843 
  def write(self, oprot):
14844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14846 
      return
14847 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14848 
    if self.transactionId is not None:
14849 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14850 
      oprot.writeI64(self.transactionId)
14851 
      oprot.writeFieldEnd()
14852 
    if self.category is not None:
14853 
      oprot.writeFieldBegin('category', TType.I32, 2)
14854 
      oprot.writeI32(self.category)
14855 
      oprot.writeFieldEnd()
14856 
    oprot.writeFieldStop()
14857 
    oprot.writeStructEnd()
14858 
 
14859 
  def validate(self):
14860 
    return
14861 
 
14862 
 
14863 
  def __repr__(self):
14864 
    L = ['%s=%r' % (key, value)
14865 
      for key, value in self.__dict__.iteritems()]
14866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14867 
 
14868 
  def __eq__(self, other):
14869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14870 
 
14871 
  def __ne__(self, other):
14872 
    return not (self == other)
14873 
 
14874 
class markTransactionAsProcessed_result:
14875 
 
14876 
  thrift_spec = (
14877 
  )
14878 
 
14879 
  def read(self, iprot):
14880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14882 
      return
14883 
    iprot.readStructBegin()
14884 
    while True:
14885 
      (fname, ftype, fid) = iprot.readFieldBegin()
14886 
      if ftype == TType.STOP:
14887 
        break
14888 
      else:
14889 
        iprot.skip(ftype)
14890 
      iprot.readFieldEnd()
14891 
    iprot.readStructEnd()
14892 
 
14893 
  def write(self, oprot):
14894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14896 
      return
14897 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14898 
    oprot.writeFieldStop()
14899 
    oprot.writeStructEnd()
14900 
 
14901 
  def validate(self):
14902 
    return
14903 
 
14904 
 
14905 
  def __repr__(self):
14906 
    L = ['%s=%r' % (key, value)
14907 
      for key, value in self.__dict__.iteritems()]
14908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14909 
 
14910 
  def __eq__(self, other):
14911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14912 
 
14913 
  def __ne__(self, other):
14914 
    return not (self == other)
4018 chandransh 14915 
 
14916 
class getItemWiseRiskyOrdersCount_args:
14917 
 
14918 
  thrift_spec = (
14919 
  )
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 
      else:
14931 
        iprot.skip(ftype)
14932 
      iprot.readFieldEnd()
14933 
    iprot.readStructEnd()
14934 
 
14935 
  def write(self, oprot):
14936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14938 
      return
14939 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14940 
    oprot.writeFieldStop()
14941 
    oprot.writeStructEnd()
14942 
 
14943 
  def validate(self):
14944 
    return
14945 
 
14946 
 
14947 
  def __repr__(self):
14948 
    L = ['%s=%r' % (key, value)
14949 
      for key, value in self.__dict__.iteritems()]
14950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14951 
 
14952 
  def __eq__(self, other):
14953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14954 
 
14955 
  def __ne__(self, other):
14956 
    return not (self == other)
14957 
 
14958 
class getItemWiseRiskyOrdersCount_result:
14959 
  """
14960 
  Attributes:
14961 
   - success
14962 
  """
14963 
 
14964 
  thrift_spec = (
14965 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14966 
  )
14967 
 
14968 
  def __init__(self, success=None,):
14969 
    self.success = success
14970 
 
14971 
  def read(self, iprot):
14972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14974 
      return
14975 
    iprot.readStructBegin()
14976 
    while True:
14977 
      (fname, ftype, fid) = iprot.readFieldBegin()
14978 
      if ftype == TType.STOP:
14979 
        break
14980 
      if fid == 0:
14981 
        if ftype == TType.MAP:
14982 
          self.success = {}
4586 mandeep.dh 14983 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
14984 
          for _i256 in xrange(_size252):
14985 
            _key257 = iprot.readI64();
14986 
            _val258 = iprot.readI64();
14987 
            self.success[_key257] = _val258
4018 chandransh 14988 
          iprot.readMapEnd()
14989 
        else:
14990 
          iprot.skip(ftype)
14991 
      else:
14992 
        iprot.skip(ftype)
14993 
      iprot.readFieldEnd()
14994 
    iprot.readStructEnd()
14995 
 
14996 
  def write(self, oprot):
14997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14999 
      return
15000 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15001 
    if self.success is not None:
15002 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15003 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 15004 
      for kiter259,viter260 in self.success.items():
15005 
        oprot.writeI64(kiter259)
15006 
        oprot.writeI64(viter260)
4018 chandransh 15007 
      oprot.writeMapEnd()
15008 
      oprot.writeFieldEnd()
15009 
    oprot.writeFieldStop()
15010 
    oprot.writeStructEnd()
15011 
 
15012 
  def validate(self):
15013 
    return
15014 
 
15015 
 
15016 
  def __repr__(self):
15017 
    L = ['%s=%r' % (key, value)
15018 
      for key, value in self.__dict__.iteritems()]
15019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15020 
 
15021 
  def __eq__(self, other):
15022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15023 
 
15024 
  def __ne__(self, other):
15025 
    return not (self == other)
4247 rajveer 15026 
 
4295 varun.gupt 15027 
class getOrdersForItemIds_args:
15028 
  """
15029 
  Attributes:
15030 
   - itemIds
15031 
  """
15032 
 
15033 
  thrift_spec = (
15034 
    None, # 0
15035 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15036 
  )
15037 
 
15038 
  def __init__(self, itemIds=None,):
15039 
    self.itemIds = itemIds
15040 
 
15041 
  def read(self, iprot):
15042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15044 
      return
15045 
    iprot.readStructBegin()
15046 
    while True:
15047 
      (fname, ftype, fid) = iprot.readFieldBegin()
15048 
      if ftype == TType.STOP:
15049 
        break
15050 
      if fid == 1:
15051 
        if ftype == TType.LIST:
15052 
          self.itemIds = []
4586 mandeep.dh 15053 
          (_etype264, _size261) = iprot.readListBegin()
15054 
          for _i265 in xrange(_size261):
15055 
            _elem266 = iprot.readI64();
15056 
            self.itemIds.append(_elem266)
4295 varun.gupt 15057 
          iprot.readListEnd()
15058 
        else:
15059 
          iprot.skip(ftype)
15060 
      else:
15061 
        iprot.skip(ftype)
15062 
      iprot.readFieldEnd()
15063 
    iprot.readStructEnd()
15064 
 
15065 
  def write(self, oprot):
15066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15068 
      return
15069 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15070 
    if self.itemIds is not None:
15071 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15072 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15073 
      for iter267 in self.itemIds:
15074 
        oprot.writeI64(iter267)
4295 varun.gupt 15075 
      oprot.writeListEnd()
15076 
      oprot.writeFieldEnd()
15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
15094 
 
15095 
class getOrdersForItemIds_result:
15096 
  """
15097 
  Attributes:
15098 
   - success
15099 
  """
15100 
 
15101 
  thrift_spec = (
15102 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15103 
  )
15104 
 
15105 
  def __init__(self, success=None,):
15106 
    self.success = success
15107 
 
15108 
  def read(self, iprot):
15109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15111 
      return
15112 
    iprot.readStructBegin()
15113 
    while True:
15114 
      (fname, ftype, fid) = iprot.readFieldBegin()
15115 
      if ftype == TType.STOP:
15116 
        break
15117 
      if fid == 0:
15118 
        if ftype == TType.LIST:
15119 
          self.success = []
4586 mandeep.dh 15120 
          (_etype271, _size268) = iprot.readListBegin()
15121 
          for _i272 in xrange(_size268):
15122 
            _elem273 = Order()
15123 
            _elem273.read(iprot)
15124 
            self.success.append(_elem273)
4295 varun.gupt 15125 
          iprot.readListEnd()
15126 
        else:
15127 
          iprot.skip(ftype)
15128 
      else:
15129 
        iprot.skip(ftype)
15130 
      iprot.readFieldEnd()
15131 
    iprot.readStructEnd()
15132 
 
15133 
  def write(self, oprot):
15134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15136 
      return
15137 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15138 
    if self.success is not None:
15139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15141 
      for iter274 in self.success:
15142 
        iter274.write(oprot)
4295 varun.gupt 15143 
      oprot.writeListEnd()
15144 
      oprot.writeFieldEnd()
15145 
    oprot.writeFieldStop()
15146 
    oprot.writeStructEnd()
15147 
 
15148 
  def validate(self):
15149 
    return
15150 
 
15151 
 
15152 
  def __repr__(self):
15153 
    L = ['%s=%r' % (key, value)
15154 
      for key, value in self.__dict__.iteritems()]
15155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15156 
 
15157 
  def __eq__(self, other):
15158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15159 
 
15160 
  def __ne__(self, other):
15161 
    return not (self == other)
15162 
 
4247 rajveer 15163 
class markOrderCancellationRequestReceived_args:
15164 
  """
15165 
  Attributes:
15166 
   - orderId
15167 
  """
15168 
 
15169 
  thrift_spec = (
15170 
    None, # 0
15171 
    (1, TType.I64, 'orderId', None, None, ), # 1
15172 
  )
15173 
 
15174 
  def __init__(self, orderId=None,):
15175 
    self.orderId = orderId
15176 
 
15177 
  def read(self, iprot):
15178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15180 
      return
15181 
    iprot.readStructBegin()
15182 
    while True:
15183 
      (fname, ftype, fid) = iprot.readFieldBegin()
15184 
      if ftype == TType.STOP:
15185 
        break
15186 
      if fid == 1:
15187 
        if ftype == TType.I64:
15188 
          self.orderId = iprot.readI64();
15189 
        else:
15190 
          iprot.skip(ftype)
15191 
      else:
15192 
        iprot.skip(ftype)
15193 
      iprot.readFieldEnd()
15194 
    iprot.readStructEnd()
15195 
 
15196 
  def write(self, oprot):
15197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15199 
      return
15200 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15201 
    if self.orderId is not None:
15202 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15203 
      oprot.writeI64(self.orderId)
15204 
      oprot.writeFieldEnd()
15205 
    oprot.writeFieldStop()
15206 
    oprot.writeStructEnd()
15207 
 
15208 
  def validate(self):
15209 
    return
15210 
 
15211 
 
15212 
  def __repr__(self):
15213 
    L = ['%s=%r' % (key, value)
15214 
      for key, value in self.__dict__.iteritems()]
15215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15216 
 
15217 
  def __eq__(self, other):
15218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15219 
 
15220 
  def __ne__(self, other):
15221 
    return not (self == other)
15222 
 
15223 
class markOrderCancellationRequestReceived_result:
15224 
  """
15225 
  Attributes:
15226 
   - ex
15227 
  """
15228 
 
15229 
  thrift_spec = (
15230 
    None, # 0
15231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15232 
  )
15233 
 
15234 
  def __init__(self, ex=None,):
15235 
    self.ex = ex
15236 
 
15237 
  def read(self, iprot):
15238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15240 
      return
15241 
    iprot.readStructBegin()
15242 
    while True:
15243 
      (fname, ftype, fid) = iprot.readFieldBegin()
15244 
      if ftype == TType.STOP:
15245 
        break
15246 
      if fid == 1:
15247 
        if ftype == TType.STRUCT:
15248 
          self.ex = TransactionServiceException()
15249 
          self.ex.read(iprot)
15250 
        else:
15251 
          iprot.skip(ftype)
15252 
      else:
15253 
        iprot.skip(ftype)
15254 
      iprot.readFieldEnd()
15255 
    iprot.readStructEnd()
15256 
 
15257 
  def write(self, oprot):
15258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15260 
      return
15261 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15262 
    if self.ex is not None:
15263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15264 
      self.ex.write(oprot)
15265 
      oprot.writeFieldEnd()
15266 
    oprot.writeFieldStop()
15267 
    oprot.writeStructEnd()
15268 
 
15269 
  def validate(self):
15270 
    return
15271 
 
15272 
 
15273 
  def __repr__(self):
15274 
    L = ['%s=%r' % (key, value)
15275 
      for key, value in self.__dict__.iteritems()]
15276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15277 
 
15278 
  def __eq__(self, other):
15279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15280 
 
15281 
  def __ne__(self, other):
15282 
    return not (self == other)
15283 
 
15284 
class markOrderCancellationRequestConfirmed_args:
15285 
  """
15286 
  Attributes:
15287 
   - orderId
15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    None, # 0
15292 
    (1, TType.I64, 'orderId', None, None, ), # 1
15293 
  )
15294 
 
15295 
  def __init__(self, orderId=None,):
15296 
    self.orderId = orderId
15297 
 
15298 
  def read(self, iprot):
15299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15301 
      return
15302 
    iprot.readStructBegin()
15303 
    while True:
15304 
      (fname, ftype, fid) = iprot.readFieldBegin()
15305 
      if ftype == TType.STOP:
15306 
        break
15307 
      if fid == 1:
15308 
        if ftype == TType.I64:
15309 
          self.orderId = iprot.readI64();
15310 
        else:
15311 
          iprot.skip(ftype)
15312 
      else:
15313 
        iprot.skip(ftype)
15314 
      iprot.readFieldEnd()
15315 
    iprot.readStructEnd()
15316 
 
15317 
  def write(self, oprot):
15318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15320 
      return
15321 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15322 
    if self.orderId is not None:
15323 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15324 
      oprot.writeI64(self.orderId)
15325 
      oprot.writeFieldEnd()
15326 
    oprot.writeFieldStop()
15327 
    oprot.writeStructEnd()
15328 
 
15329 
  def validate(self):
15330 
    return
15331 
 
15332 
 
15333 
  def __repr__(self):
15334 
    L = ['%s=%r' % (key, value)
15335 
      for key, value in self.__dict__.iteritems()]
15336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15337 
 
15338 
  def __eq__(self, other):
15339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15340 
 
15341 
  def __ne__(self, other):
15342 
    return not (self == other)
15343 
 
15344 
class markOrderCancellationRequestConfirmed_result:
15345 
  """
15346 
  Attributes:
15347 
   - ex
15348 
  """
15349 
 
15350 
  thrift_spec = (
15351 
    None, # 0
15352 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15353 
  )
15354 
 
15355 
  def __init__(self, ex=None,):
15356 
    self.ex = ex
15357 
 
15358 
  def read(self, iprot):
15359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15361 
      return
15362 
    iprot.readStructBegin()
15363 
    while True:
15364 
      (fname, ftype, fid) = iprot.readFieldBegin()
15365 
      if ftype == TType.STOP:
15366 
        break
15367 
      if fid == 1:
15368 
        if ftype == TType.STRUCT:
15369 
          self.ex = TransactionServiceException()
15370 
          self.ex.read(iprot)
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      else:
15374 
        iprot.skip(ftype)
15375 
      iprot.readFieldEnd()
15376 
    iprot.readStructEnd()
15377 
 
15378 
  def write(self, oprot):
15379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15381 
      return
15382 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15383 
    if self.ex is not None:
15384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15385 
      self.ex.write(oprot)
15386 
      oprot.writeFieldEnd()
15387 
    oprot.writeFieldStop()
15388 
    oprot.writeStructEnd()
15389 
 
15390 
  def validate(self):
15391 
    return
15392 
 
15393 
 
15394 
  def __repr__(self):
15395 
    L = ['%s=%r' % (key, value)
15396 
      for key, value in self.__dict__.iteritems()]
15397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15398 
 
15399 
  def __eq__(self, other):
15400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15401 
 
15402 
  def __ne__(self, other):
15403 
    return not (self == other)
15404 
 
15405 
class markOrderCancellationRequestDenied_args:
15406 
  """
15407 
  Attributes:
15408 
   - orderId
15409 
  """
15410 
 
15411 
  thrift_spec = (
15412 
    None, # 0
15413 
    (1, TType.I64, 'orderId', None, None, ), # 1
15414 
  )
15415 
 
15416 
  def __init__(self, orderId=None,):
15417 
    self.orderId = orderId
15418 
 
15419 
  def read(self, iprot):
15420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15422 
      return
15423 
    iprot.readStructBegin()
15424 
    while True:
15425 
      (fname, ftype, fid) = iprot.readFieldBegin()
15426 
      if ftype == TType.STOP:
15427 
        break
15428 
      if fid == 1:
15429 
        if ftype == TType.I64:
15430 
          self.orderId = iprot.readI64();
15431 
        else:
15432 
          iprot.skip(ftype)
15433 
      else:
15434 
        iprot.skip(ftype)
15435 
      iprot.readFieldEnd()
15436 
    iprot.readStructEnd()
15437 
 
15438 
  def write(self, oprot):
15439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15441 
      return
15442 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15443 
    if self.orderId is not None:
15444 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15445 
      oprot.writeI64(self.orderId)
15446 
      oprot.writeFieldEnd()
15447 
    oprot.writeFieldStop()
15448 
    oprot.writeStructEnd()
15449 
 
15450 
  def validate(self):
15451 
    return
15452 
 
15453 
 
15454 
  def __repr__(self):
15455 
    L = ['%s=%r' % (key, value)
15456 
      for key, value in self.__dict__.iteritems()]
15457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15458 
 
15459 
  def __eq__(self, other):
15460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15461 
 
15462 
  def __ne__(self, other):
15463 
    return not (self == other)
15464 
 
15465 
class markOrderCancellationRequestDenied_result:
15466 
  """
15467 
  Attributes:
15468 
   - ex
15469 
  """
15470 
 
15471 
  thrift_spec = (
15472 
    None, # 0
15473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15474 
  )
15475 
 
15476 
  def __init__(self, ex=None,):
15477 
    self.ex = ex
15478 
 
15479 
  def read(self, iprot):
15480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15482 
      return
15483 
    iprot.readStructBegin()
15484 
    while True:
15485 
      (fname, ftype, fid) = iprot.readFieldBegin()
15486 
      if ftype == TType.STOP:
15487 
        break
15488 
      if fid == 1:
15489 
        if ftype == TType.STRUCT:
15490 
          self.ex = TransactionServiceException()
15491 
          self.ex.read(iprot)
15492 
        else:
15493 
          iprot.skip(ftype)
15494 
      else:
15495 
        iprot.skip(ftype)
15496 
      iprot.readFieldEnd()
15497 
    iprot.readStructEnd()
15498 
 
15499 
  def write(self, oprot):
15500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15502 
      return
15503 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15504 
    if self.ex is not None:
15505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15506 
      self.ex.write(oprot)
15507 
      oprot.writeFieldEnd()
15508 
    oprot.writeFieldStop()
15509 
    oprot.writeStructEnd()
15510 
 
15511 
  def validate(self):
15512 
    return
15513 
 
15514 
 
15515 
  def __repr__(self):
15516 
    L = ['%s=%r' % (key, value)
15517 
      for key, value in self.__dict__.iteritems()]
15518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15519 
 
15520 
  def __eq__(self, other):
15521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15522 
 
15523 
  def __ne__(self, other):
15524 
    return not (self == other)
15525 
 
4258 rajveer 15526 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15527 
  """
15528 
  Attributes:
4258 rajveer 15529 
   - transactionId
4247 rajveer 15530 
  """
15531 
 
15532 
  thrift_spec = (
15533 
    None, # 0
4258 rajveer 15534 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15535 
  )
15536 
 
4258 rajveer 15537 
  def __init__(self, transactionId=None,):
15538 
    self.transactionId = transactionId
4247 rajveer 15539 
 
15540 
  def read(self, iprot):
15541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15543 
      return
15544 
    iprot.readStructBegin()
15545 
    while True:
15546 
      (fname, ftype, fid) = iprot.readFieldBegin()
15547 
      if ftype == TType.STOP:
15548 
        break
15549 
      if fid == 1:
15550 
        if ftype == TType.I64:
4258 rajveer 15551 
          self.transactionId = iprot.readI64();
4247 rajveer 15552 
        else:
15553 
          iprot.skip(ftype)
15554 
      else:
15555 
        iprot.skip(ftype)
15556 
      iprot.readFieldEnd()
15557 
    iprot.readStructEnd()
15558 
 
15559 
  def write(self, oprot):
15560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15562 
      return
4258 rajveer 15563 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15564 
    if self.transactionId is not None:
15565 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15566 
      oprot.writeI64(self.transactionId)
4247 rajveer 15567 
      oprot.writeFieldEnd()
15568 
    oprot.writeFieldStop()
15569 
    oprot.writeStructEnd()
15570 
 
15571 
  def validate(self):
15572 
    return
15573 
 
15574 
 
15575 
  def __repr__(self):
15576 
    L = ['%s=%r' % (key, value)
15577 
      for key, value in self.__dict__.iteritems()]
15578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15579 
 
15580 
  def __eq__(self, other):
15581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15582 
 
15583 
  def __ne__(self, other):
15584 
    return not (self == other)
15585 
 
4258 rajveer 15586 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15587 
  """
15588 
  Attributes:
15589 
   - ex
15590 
  """
15591 
 
15592 
  thrift_spec = (
15593 
    None, # 0
15594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15595 
  )
15596 
 
15597 
  def __init__(self, ex=None,):
15598 
    self.ex = ex
15599 
 
15600 
  def read(self, iprot):
15601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15603 
      return
15604 
    iprot.readStructBegin()
15605 
    while True:
15606 
      (fname, ftype, fid) = iprot.readFieldBegin()
15607 
      if ftype == TType.STOP:
15608 
        break
15609 
      if fid == 1:
15610 
        if ftype == TType.STRUCT:
15611 
          self.ex = TransactionServiceException()
15612 
          self.ex.read(iprot)
15613 
        else:
15614 
          iprot.skip(ftype)
15615 
      else:
15616 
        iprot.skip(ftype)
15617 
      iprot.readFieldEnd()
15618 
    iprot.readStructEnd()
15619 
 
15620 
  def write(self, oprot):
15621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15623 
      return
4258 rajveer 15624 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15625 
    if self.ex is not None:
15626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15627 
      self.ex.write(oprot)
15628 
      oprot.writeFieldEnd()
15629 
    oprot.writeFieldStop()
15630 
    oprot.writeStructEnd()
15631 
 
15632 
  def validate(self):
15633 
    return
15634 
 
15635 
 
15636 
  def __repr__(self):
15637 
    L = ['%s=%r' % (key, value)
15638 
      for key, value in self.__dict__.iteritems()]
15639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15640 
 
15641 
  def __eq__(self, other):
15642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15643 
 
15644 
  def __ne__(self, other):
15645 
    return not (self == other)
4259 anupam.sin 15646 
 
15647 
class refundTransaction_args:
15648 
  """
15649 
  Attributes:
15650 
   - transactionId
15651 
   - refundedBy
15652 
   - reason
15653 
  """
15654 
 
15655 
  thrift_spec = (
15656 
    None, # 0
15657 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15658 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15659 
    (3, TType.STRING, 'reason', None, None, ), # 3
15660 
  )
15661 
 
15662 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15663 
    self.transactionId = transactionId
15664 
    self.refundedBy = refundedBy
15665 
    self.reason = reason
15666 
 
15667 
  def read(self, iprot):
15668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15670 
      return
15671 
    iprot.readStructBegin()
15672 
    while True:
15673 
      (fname, ftype, fid) = iprot.readFieldBegin()
15674 
      if ftype == TType.STOP:
15675 
        break
15676 
      if fid == 1:
15677 
        if ftype == TType.I64:
15678 
          self.transactionId = iprot.readI64();
15679 
        else:
15680 
          iprot.skip(ftype)
15681 
      elif fid == 2:
15682 
        if ftype == TType.STRING:
15683 
          self.refundedBy = iprot.readString();
15684 
        else:
15685 
          iprot.skip(ftype)
15686 
      elif fid == 3:
15687 
        if ftype == TType.STRING:
15688 
          self.reason = iprot.readString();
15689 
        else:
15690 
          iprot.skip(ftype)
15691 
      else:
15692 
        iprot.skip(ftype)
15693 
      iprot.readFieldEnd()
15694 
    iprot.readStructEnd()
15695 
 
15696 
  def write(self, oprot):
15697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15699 
      return
15700 
    oprot.writeStructBegin('refundTransaction_args')
15701 
    if self.transactionId is not None:
15702 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15703 
      oprot.writeI64(self.transactionId)
15704 
      oprot.writeFieldEnd()
15705 
    if self.refundedBy is not None:
15706 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15707 
      oprot.writeString(self.refundedBy)
15708 
      oprot.writeFieldEnd()
15709 
    if self.reason is not None:
15710 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15711 
      oprot.writeString(self.reason)
15712 
      oprot.writeFieldEnd()
15713 
    oprot.writeFieldStop()
15714 
    oprot.writeStructEnd()
15715 
 
15716 
  def validate(self):
15717 
    return
15718 
 
15719 
 
15720 
  def __repr__(self):
15721 
    L = ['%s=%r' % (key, value)
15722 
      for key, value in self.__dict__.iteritems()]
15723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15724 
 
15725 
  def __eq__(self, other):
15726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15727 
 
15728 
  def __ne__(self, other):
15729 
    return not (self == other)
15730 
 
15731 
class refundTransaction_result:
15732 
  """
15733 
  Attributes:
15734 
   - ex
15735 
  """
15736 
 
15737 
  thrift_spec = (
15738 
    None, # 0
15739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15740 
  )
15741 
 
15742 
  def __init__(self, ex=None,):
15743 
    self.ex = ex
15744 
 
15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
15754 
      if fid == 1:
15755 
        if ftype == TType.STRUCT:
15756 
          self.ex = TransactionServiceException()
15757 
          self.ex.read(iprot)
15758 
        else:
15759 
          iprot.skip(ftype)
15760 
      else:
15761 
        iprot.skip(ftype)
15762 
      iprot.readFieldEnd()
15763 
    iprot.readStructEnd()
15764 
 
15765 
  def write(self, oprot):
15766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15768 
      return
15769 
    oprot.writeStructBegin('refundTransaction_result')
15770 
    if self.ex is not None:
15771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15772 
      self.ex.write(oprot)
15773 
      oprot.writeFieldEnd()
15774 
    oprot.writeFieldStop()
15775 
    oprot.writeStructEnd()
15776 
 
15777 
  def validate(self):
15778 
    return
15779 
 
15780 
 
15781 
  def __repr__(self):
15782 
    L = ['%s=%r' % (key, value)
15783 
      for key, value in self.__dict__.iteritems()]
15784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15785 
 
15786 
  def __eq__(self, other):
15787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15788 
 
15789 
  def __ne__(self, other):
15790 
    return not (self == other)
4285 rajveer 15791 
 
4324 mandeep.dh 15792 
class updateShipmentAddress_args:
15793 
  """
15794 
  Attributes:
15795 
   - orderId
15796 
   - addressId
15797 
  """
15798 
 
15799 
  thrift_spec = (
15800 
    None, # 0
15801 
    (1, TType.I64, 'orderId', None, None, ), # 1
15802 
    (2, TType.I64, 'addressId', None, None, ), # 2
15803 
  )
15804 
 
15805 
  def __init__(self, orderId=None, addressId=None,):
15806 
    self.orderId = orderId
15807 
    self.addressId = addressId
15808 
 
15809 
  def read(self, iprot):
15810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15812 
      return
15813 
    iprot.readStructBegin()
15814 
    while True:
15815 
      (fname, ftype, fid) = iprot.readFieldBegin()
15816 
      if ftype == TType.STOP:
15817 
        break
15818 
      if fid == 1:
15819 
        if ftype == TType.I64:
15820 
          self.orderId = iprot.readI64();
15821 
        else:
15822 
          iprot.skip(ftype)
15823 
      elif fid == 2:
15824 
        if ftype == TType.I64:
15825 
          self.addressId = iprot.readI64();
15826 
        else:
15827 
          iprot.skip(ftype)
15828 
      else:
15829 
        iprot.skip(ftype)
15830 
      iprot.readFieldEnd()
15831 
    iprot.readStructEnd()
15832 
 
15833 
  def write(self, oprot):
15834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15836 
      return
15837 
    oprot.writeStructBegin('updateShipmentAddress_args')
15838 
    if self.orderId is not None:
15839 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15840 
      oprot.writeI64(self.orderId)
15841 
      oprot.writeFieldEnd()
15842 
    if self.addressId is not None:
15843 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15844 
      oprot.writeI64(self.addressId)
15845 
      oprot.writeFieldEnd()
15846 
    oprot.writeFieldStop()
15847 
    oprot.writeStructEnd()
15848 
 
15849 
  def validate(self):
15850 
    return
15851 
 
15852 
 
15853 
  def __repr__(self):
15854 
    L = ['%s=%r' % (key, value)
15855 
      for key, value in self.__dict__.iteritems()]
15856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15857 
 
15858 
  def __eq__(self, other):
15859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15860 
 
15861 
  def __ne__(self, other):
15862 
    return not (self == other)
15863 
 
15864 
class updateShipmentAddress_result:
15865 
  """
15866 
  Attributes:
15867 
   - ex
15868 
  """
15869 
 
15870 
  thrift_spec = (
15871 
    None, # 0
15872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15873 
  )
15874 
 
15875 
  def __init__(self, ex=None,):
15876 
    self.ex = ex
15877 
 
15878 
  def read(self, iprot):
15879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15881 
      return
15882 
    iprot.readStructBegin()
15883 
    while True:
15884 
      (fname, ftype, fid) = iprot.readFieldBegin()
15885 
      if ftype == TType.STOP:
15886 
        break
15887 
      if fid == 1:
15888 
        if ftype == TType.STRUCT:
15889 
          self.ex = TransactionServiceException()
15890 
          self.ex.read(iprot)
15891 
        else:
15892 
          iprot.skip(ftype)
15893 
      else:
15894 
        iprot.skip(ftype)
15895 
      iprot.readFieldEnd()
15896 
    iprot.readStructEnd()
15897 
 
15898 
  def write(self, oprot):
15899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15901 
      return
15902 
    oprot.writeStructBegin('updateShipmentAddress_result')
15903 
    if self.ex is not None:
15904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15905 
      self.ex.write(oprot)
15906 
      oprot.writeFieldEnd()
15907 
    oprot.writeFieldStop()
15908 
    oprot.writeStructEnd()
15909 
 
15910 
  def validate(self):
15911 
    return
15912 
 
15913 
 
15914 
  def __repr__(self):
15915 
    L = ['%s=%r' % (key, value)
15916 
      for key, value in self.__dict__.iteritems()]
15917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15918 
 
15919 
  def __eq__(self, other):
15920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15921 
 
15922 
  def __ne__(self, other):
15923 
    return not (self == other)
15924 
 
4285 rajveer 15925 
class acceptOrdersForItemId_args:
15926 
  """
15927 
  Attributes:
15928 
   - itemId
15929 
   - inventory
15930 
  """
15931 
 
15932 
  thrift_spec = (
15933 
    None, # 0
15934 
    (1, TType.I64, 'itemId', None, None, ), # 1
15935 
    (2, TType.I64, 'inventory', None, None, ), # 2
15936 
  )
15937 
 
15938 
  def __init__(self, itemId=None, inventory=None,):
15939 
    self.itemId = itemId
15940 
    self.inventory = inventory
15941 
 
15942 
  def read(self, iprot):
15943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15945 
      return
15946 
    iprot.readStructBegin()
15947 
    while True:
15948 
      (fname, ftype, fid) = iprot.readFieldBegin()
15949 
      if ftype == TType.STOP:
15950 
        break
15951 
      if fid == 1:
15952 
        if ftype == TType.I64:
15953 
          self.itemId = iprot.readI64();
15954 
        else:
15955 
          iprot.skip(ftype)
15956 
      elif fid == 2:
15957 
        if ftype == TType.I64:
15958 
          self.inventory = iprot.readI64();
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15971 
    if self.itemId is not None:
15972 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15973 
      oprot.writeI64(self.itemId)
15974 
      oprot.writeFieldEnd()
15975 
    if self.inventory is not None:
15976 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15977 
      oprot.writeI64(self.inventory)
15978 
      oprot.writeFieldEnd()
15979 
    oprot.writeFieldStop()
15980 
    oprot.writeStructEnd()
15981 
 
15982 
  def validate(self):
15983 
    return
15984 
 
15985 
 
15986 
  def __repr__(self):
15987 
    L = ['%s=%r' % (key, value)
15988 
      for key, value in self.__dict__.iteritems()]
15989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15990 
 
15991 
  def __eq__(self, other):
15992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15993 
 
15994 
  def __ne__(self, other):
15995 
    return not (self == other)
15996 
 
15997 
class acceptOrdersForItemId_result:
15998 
  """
15999 
  Attributes:
16000 
   - success
16001 
   - ex
16002 
  """
16003 
 
16004 
  thrift_spec = (
16005 
    (0, TType.BOOL, 'success', None, None, ), # 0
16006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16007 
  )
16008 
 
16009 
  def __init__(self, success=None, ex=None,):
16010 
    self.success = success
16011 
    self.ex = ex
16012 
 
16013 
  def read(self, iprot):
16014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16016 
      return
16017 
    iprot.readStructBegin()
16018 
    while True:
16019 
      (fname, ftype, fid) = iprot.readFieldBegin()
16020 
      if ftype == TType.STOP:
16021 
        break
16022 
      if fid == 0:
16023 
        if ftype == TType.BOOL:
16024 
          self.success = iprot.readBool();
16025 
        else:
16026 
          iprot.skip(ftype)
16027 
      elif fid == 1:
16028 
        if ftype == TType.STRUCT:
16029 
          self.ex = TransactionServiceException()
16030 
          self.ex.read(iprot)
16031 
        else:
16032 
          iprot.skip(ftype)
16033 
      else:
16034 
        iprot.skip(ftype)
16035 
      iprot.readFieldEnd()
16036 
    iprot.readStructEnd()
16037 
 
16038 
  def write(self, oprot):
16039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16041 
      return
16042 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16043 
    if self.success is not None:
16044 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16045 
      oprot.writeBool(self.success)
16046 
      oprot.writeFieldEnd()
16047 
    if self.ex is not None:
16048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16049 
      self.ex.write(oprot)
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
4303 rajveer 16068 
 
16069 
class markOrdersAsPORaised_args:
16070 
  """
16071 
  Attributes:
16072 
   - vendorId
16073 
   - itemId
16074 
   - quantity
16075 
   - estimate
4369 rajveer 16076 
   - isReminder
4303 rajveer 16077 
  """
16078 
 
16079 
  thrift_spec = (
16080 
    None, # 0
16081 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16082 
    (2, TType.I64, 'itemId', None, None, ), # 2
16083 
    (3, TType.I64, 'quantity', None, None, ), # 3
16084 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16085 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16086 
  )
16087 
 
4369 rajveer 16088 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16089 
    self.vendorId = vendorId
16090 
    self.itemId = itemId
16091 
    self.quantity = quantity
16092 
    self.estimate = estimate
4369 rajveer 16093 
    self.isReminder = isReminder
4303 rajveer 16094 
 
16095 
  def read(self, iprot):
16096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16098 
      return
16099 
    iprot.readStructBegin()
16100 
    while True:
16101 
      (fname, ftype, fid) = iprot.readFieldBegin()
16102 
      if ftype == TType.STOP:
16103 
        break
16104 
      if fid == 1:
16105 
        if ftype == TType.I64:
16106 
          self.vendorId = iprot.readI64();
16107 
        else:
16108 
          iprot.skip(ftype)
16109 
      elif fid == 2:
16110 
        if ftype == TType.I64:
16111 
          self.itemId = iprot.readI64();
16112 
        else:
16113 
          iprot.skip(ftype)
16114 
      elif fid == 3:
16115 
        if ftype == TType.I64:
16116 
          self.quantity = iprot.readI64();
16117 
        else:
16118 
          iprot.skip(ftype)
16119 
      elif fid == 4:
16120 
        if ftype == TType.I64:
16121 
          self.estimate = iprot.readI64();
16122 
        else:
16123 
          iprot.skip(ftype)
4369 rajveer 16124 
      elif fid == 5:
16125 
        if ftype == TType.BOOL:
16126 
          self.isReminder = iprot.readBool();
16127 
        else:
16128 
          iprot.skip(ftype)
4303 rajveer 16129 
      else:
16130 
        iprot.skip(ftype)
16131 
      iprot.readFieldEnd()
16132 
    iprot.readStructEnd()
16133 
 
16134 
  def write(self, oprot):
16135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16137 
      return
16138 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16139 
    if self.vendorId is not None:
16140 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16141 
      oprot.writeI64(self.vendorId)
16142 
      oprot.writeFieldEnd()
16143 
    if self.itemId is not None:
16144 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16145 
      oprot.writeI64(self.itemId)
16146 
      oprot.writeFieldEnd()
16147 
    if self.quantity is not None:
16148 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16149 
      oprot.writeI64(self.quantity)
16150 
      oprot.writeFieldEnd()
16151 
    if self.estimate is not None:
16152 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16153 
      oprot.writeI64(self.estimate)
16154 
      oprot.writeFieldEnd()
4369 rajveer 16155 
    if self.isReminder is not None:
16156 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16157 
      oprot.writeBool(self.isReminder)
16158 
      oprot.writeFieldEnd()
4303 rajveer 16159 
    oprot.writeFieldStop()
16160 
    oprot.writeStructEnd()
16161 
 
16162 
  def validate(self):
16163 
    return
16164 
 
16165 
 
16166 
  def __repr__(self):
16167 
    L = ['%s=%r' % (key, value)
16168 
      for key, value in self.__dict__.iteritems()]
16169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16170 
 
16171 
  def __eq__(self, other):
16172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16173 
 
16174 
  def __ne__(self, other):
16175 
    return not (self == other)
16176 
 
16177 
class markOrdersAsPORaised_result:
16178 
  """
16179 
  Attributes:
16180 
   - ex
16181 
  """
16182 
 
16183 
  thrift_spec = (
16184 
    None, # 0
16185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16186 
  )
16187 
 
16188 
  def __init__(self, ex=None,):
16189 
    self.ex = ex
16190 
 
16191 
  def read(self, iprot):
16192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16194 
      return
16195 
    iprot.readStructBegin()
16196 
    while True:
16197 
      (fname, ftype, fid) = iprot.readFieldBegin()
16198 
      if ftype == TType.STOP:
16199 
        break
16200 
      if fid == 1:
16201 
        if ftype == TType.STRUCT:
16202 
          self.ex = TransactionServiceException()
16203 
          self.ex.read(iprot)
16204 
        else:
16205 
          iprot.skip(ftype)
16206 
      else:
16207 
        iprot.skip(ftype)
16208 
      iprot.readFieldEnd()
16209 
    iprot.readStructEnd()
16210 
 
16211 
  def write(self, oprot):
16212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16214 
      return
16215 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16216 
    if self.ex is not None:
16217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16218 
      self.ex.write(oprot)
16219 
      oprot.writeFieldEnd()
16220 
    oprot.writeFieldStop()
16221 
    oprot.writeStructEnd()
16222 
 
16223 
  def validate(self):
16224 
    return
16225 
 
16226 
 
16227 
  def __repr__(self):
16228 
    L = ['%s=%r' % (key, value)
16229 
      for key, value in self.__dict__.iteritems()]
16230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16231 
 
16232 
  def __eq__(self, other):
16233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16234 
 
16235 
  def __ne__(self, other):
16236 
    return not (self == other)
16237 
 
16238 
class markOrdersAsReversalInitiated_args:
16239 
  """
16240 
  Attributes:
16241 
   - vendorId
16242 
   - itemId
16243 
   - quantity
16244 
   - estimate
4369 rajveer 16245 
   - isReminder
4303 rajveer 16246 
  """
16247 
 
16248 
  thrift_spec = (
16249 
    None, # 0
16250 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16251 
    (2, TType.I64, 'itemId', None, None, ), # 2
16252 
    (3, TType.I64, 'quantity', None, None, ), # 3
16253 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16254 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16255 
  )
16256 
 
4369 rajveer 16257 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16258 
    self.vendorId = vendorId
16259 
    self.itemId = itemId
16260 
    self.quantity = quantity
16261 
    self.estimate = estimate
4369 rajveer 16262 
    self.isReminder = isReminder
4303 rajveer 16263 
 
16264 
  def read(self, iprot):
16265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16267 
      return
16268 
    iprot.readStructBegin()
16269 
    while True:
16270 
      (fname, ftype, fid) = iprot.readFieldBegin()
16271 
      if ftype == TType.STOP:
16272 
        break
16273 
      if fid == 1:
16274 
        if ftype == TType.I64:
16275 
          self.vendorId = iprot.readI64();
16276 
        else:
16277 
          iprot.skip(ftype)
16278 
      elif fid == 2:
16279 
        if ftype == TType.I64:
16280 
          self.itemId = iprot.readI64();
16281 
        else:
16282 
          iprot.skip(ftype)
16283 
      elif fid == 3:
16284 
        if ftype == TType.I64:
16285 
          self.quantity = iprot.readI64();
16286 
        else:
16287 
          iprot.skip(ftype)
16288 
      elif fid == 4:
16289 
        if ftype == TType.I64:
16290 
          self.estimate = iprot.readI64();
16291 
        else:
16292 
          iprot.skip(ftype)
4369 rajveer 16293 
      elif fid == 5:
16294 
        if ftype == TType.BOOL:
16295 
          self.isReminder = iprot.readBool();
16296 
        else:
16297 
          iprot.skip(ftype)
4303 rajveer 16298 
      else:
16299 
        iprot.skip(ftype)
16300 
      iprot.readFieldEnd()
16301 
    iprot.readStructEnd()
16302 
 
16303 
  def write(self, oprot):
16304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16306 
      return
16307 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16308 
    if self.vendorId is not None:
16309 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16310 
      oprot.writeI64(self.vendorId)
16311 
      oprot.writeFieldEnd()
16312 
    if self.itemId is not None:
16313 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16314 
      oprot.writeI64(self.itemId)
16315 
      oprot.writeFieldEnd()
16316 
    if self.quantity is not None:
16317 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16318 
      oprot.writeI64(self.quantity)
16319 
      oprot.writeFieldEnd()
16320 
    if self.estimate is not None:
16321 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16322 
      oprot.writeI64(self.estimate)
16323 
      oprot.writeFieldEnd()
4369 rajveer 16324 
    if self.isReminder is not None:
16325 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16326 
      oprot.writeBool(self.isReminder)
16327 
      oprot.writeFieldEnd()
4303 rajveer 16328 
    oprot.writeFieldStop()
16329 
    oprot.writeStructEnd()
16330 
 
16331 
  def validate(self):
16332 
    return
16333 
 
16334 
 
16335 
  def __repr__(self):
16336 
    L = ['%s=%r' % (key, value)
16337 
      for key, value in self.__dict__.iteritems()]
16338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16339 
 
16340 
  def __eq__(self, other):
16341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16342 
 
16343 
  def __ne__(self, other):
16344 
    return not (self == other)
16345 
 
16346 
class markOrdersAsReversalInitiated_result:
16347 
  """
16348 
  Attributes:
16349 
   - ex
16350 
  """
16351 
 
16352 
  thrift_spec = (
16353 
    None, # 0
16354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16355 
  )
16356 
 
16357 
  def __init__(self, ex=None,):
16358 
    self.ex = ex
16359 
 
16360 
  def read(self, iprot):
16361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16363 
      return
16364 
    iprot.readStructBegin()
16365 
    while True:
16366 
      (fname, ftype, fid) = iprot.readFieldBegin()
16367 
      if ftype == TType.STOP:
16368 
        break
16369 
      if fid == 1:
16370 
        if ftype == TType.STRUCT:
16371 
          self.ex = TransactionServiceException()
16372 
          self.ex.read(iprot)
16373 
        else:
16374 
          iprot.skip(ftype)
16375 
      else:
16376 
        iprot.skip(ftype)
16377 
      iprot.readFieldEnd()
16378 
    iprot.readStructEnd()
16379 
 
16380 
  def write(self, oprot):
16381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16383 
      return
16384 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16385 
    if self.ex is not None:
16386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16387 
      self.ex.write(oprot)
16388 
      oprot.writeFieldEnd()
16389 
    oprot.writeFieldStop()
16390 
    oprot.writeStructEnd()
16391 
 
16392 
  def validate(self):
16393 
    return
16394 
 
16395 
 
16396 
  def __repr__(self):
16397 
    L = ['%s=%r' % (key, value)
16398 
      for key, value in self.__dict__.iteritems()]
16399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16400 
 
16401 
  def __eq__(self, other):
16402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16403 
 
16404 
  def __ne__(self, other):
16405 
    return not (self == other)
16406 
 
16407 
class markOrdersAsNotAvailabke_args:
16408 
  """
16409 
  Attributes:
16410 
   - vendorId
16411 
   - itemId
16412 
   - quantity
16413 
   - estimate
4369 rajveer 16414 
   - isReminder
4303 rajveer 16415 
  """
16416 
 
16417 
  thrift_spec = (
16418 
    None, # 0
16419 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16420 
    (2, TType.I64, 'itemId', None, None, ), # 2
16421 
    (3, TType.I64, 'quantity', None, None, ), # 3
16422 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16423 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16424 
  )
16425 
 
4369 rajveer 16426 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16427 
    self.vendorId = vendorId
16428 
    self.itemId = itemId
16429 
    self.quantity = quantity
16430 
    self.estimate = estimate
4369 rajveer 16431 
    self.isReminder = isReminder
4303 rajveer 16432 
 
16433 
  def read(self, iprot):
16434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16436 
      return
16437 
    iprot.readStructBegin()
16438 
    while True:
16439 
      (fname, ftype, fid) = iprot.readFieldBegin()
16440 
      if ftype == TType.STOP:
16441 
        break
16442 
      if fid == 1:
16443 
        if ftype == TType.I64:
16444 
          self.vendorId = iprot.readI64();
16445 
        else:
16446 
          iprot.skip(ftype)
16447 
      elif fid == 2:
16448 
        if ftype == TType.I64:
16449 
          self.itemId = iprot.readI64();
16450 
        else:
16451 
          iprot.skip(ftype)
16452 
      elif fid == 3:
16453 
        if ftype == TType.I64:
16454 
          self.quantity = iprot.readI64();
16455 
        else:
16456 
          iprot.skip(ftype)
16457 
      elif fid == 4:
16458 
        if ftype == TType.I64:
16459 
          self.estimate = iprot.readI64();
16460 
        else:
16461 
          iprot.skip(ftype)
4369 rajveer 16462 
      elif fid == 5:
16463 
        if ftype == TType.BOOL:
16464 
          self.isReminder = iprot.readBool();
16465 
        else:
16466 
          iprot.skip(ftype)
4303 rajveer 16467 
      else:
16468 
        iprot.skip(ftype)
16469 
      iprot.readFieldEnd()
16470 
    iprot.readStructEnd()
16471 
 
16472 
  def write(self, oprot):
16473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16475 
      return
16476 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16477 
    if self.vendorId is not None:
16478 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16479 
      oprot.writeI64(self.vendorId)
16480 
      oprot.writeFieldEnd()
16481 
    if self.itemId is not None:
16482 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16483 
      oprot.writeI64(self.itemId)
16484 
      oprot.writeFieldEnd()
16485 
    if self.quantity is not None:
16486 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16487 
      oprot.writeI64(self.quantity)
16488 
      oprot.writeFieldEnd()
16489 
    if self.estimate is not None:
16490 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16491 
      oprot.writeI64(self.estimate)
16492 
      oprot.writeFieldEnd()
4369 rajveer 16493 
    if self.isReminder is not None:
16494 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16495 
      oprot.writeBool(self.isReminder)
16496 
      oprot.writeFieldEnd()
4303 rajveer 16497 
    oprot.writeFieldStop()
16498 
    oprot.writeStructEnd()
16499 
 
16500 
  def validate(self):
16501 
    return
16502 
 
16503 
 
16504 
  def __repr__(self):
16505 
    L = ['%s=%r' % (key, value)
16506 
      for key, value in self.__dict__.iteritems()]
16507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16508 
 
16509 
  def __eq__(self, other):
16510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16511 
 
16512 
  def __ne__(self, other):
16513 
    return not (self == other)
16514 
 
16515 
class markOrdersAsNotAvailabke_result:
16516 
  """
16517 
  Attributes:
16518 
   - ex
16519 
  """
16520 
 
16521 
  thrift_spec = (
16522 
    None, # 0
16523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16524 
  )
16525 
 
16526 
  def __init__(self, ex=None,):
16527 
    self.ex = ex
16528 
 
16529 
  def read(self, iprot):
16530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16532 
      return
16533 
    iprot.readStructBegin()
16534 
    while True:
16535 
      (fname, ftype, fid) = iprot.readFieldBegin()
16536 
      if ftype == TType.STOP:
16537 
        break
16538 
      if fid == 1:
16539 
        if ftype == TType.STRUCT:
16540 
          self.ex = TransactionServiceException()
16541 
          self.ex.read(iprot)
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      else:
16545 
        iprot.skip(ftype)
16546 
      iprot.readFieldEnd()
16547 
    iprot.readStructEnd()
16548 
 
16549 
  def write(self, oprot):
16550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16552 
      return
16553 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16554 
    if self.ex is not None:
16555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16556 
      self.ex.write(oprot)
16557 
      oprot.writeFieldEnd()
16558 
    oprot.writeFieldStop()
16559 
    oprot.writeStructEnd()
16560 
 
16561 
  def validate(self):
16562 
    return
16563 
 
16564 
 
16565 
  def __repr__(self):
16566 
    L = ['%s=%r' % (key, value)
16567 
      for key, value in self.__dict__.iteritems()]
16568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16569 
 
16570 
  def __eq__(self, other):
16571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16572 
 
16573 
  def __ne__(self, other):
16574 
    return not (self == other)
4369 rajveer 16575 
 
16576 
class markOrdersAsTimeout_args:
16577 
  """
16578 
  Attributes:
16579 
   - vendorId
16580 
  """
16581 
 
16582 
  thrift_spec = (
16583 
    None, # 0
16584 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16585 
  )
16586 
 
16587 
  def __init__(self, vendorId=None,):
16588 
    self.vendorId = vendorId
16589 
 
16590 
  def read(self, iprot):
16591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16593 
      return
16594 
    iprot.readStructBegin()
16595 
    while True:
16596 
      (fname, ftype, fid) = iprot.readFieldBegin()
16597 
      if ftype == TType.STOP:
16598 
        break
16599 
      if fid == 1:
16600 
        if ftype == TType.I64:
16601 
          self.vendorId = iprot.readI64();
16602 
        else:
16603 
          iprot.skip(ftype)
16604 
      else:
16605 
        iprot.skip(ftype)
16606 
      iprot.readFieldEnd()
16607 
    iprot.readStructEnd()
16608 
 
16609 
  def write(self, oprot):
16610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16612 
      return
16613 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16614 
    if self.vendorId is not None:
16615 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16616 
      oprot.writeI64(self.vendorId)
16617 
      oprot.writeFieldEnd()
16618 
    oprot.writeFieldStop()
16619 
    oprot.writeStructEnd()
16620 
 
16621 
  def validate(self):
16622 
    return
16623 
 
16624 
 
16625 
  def __repr__(self):
16626 
    L = ['%s=%r' % (key, value)
16627 
      for key, value in self.__dict__.iteritems()]
16628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16629 
 
16630 
  def __eq__(self, other):
16631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16632 
 
16633 
  def __ne__(self, other):
16634 
    return not (self == other)
16635 
 
16636 
class markOrdersAsTimeout_result:
16637 
  """
16638 
  Attributes:
16639 
   - success
16640 
   - ex
16641 
  """
16642 
 
16643 
  thrift_spec = (
16644 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16646 
  )
16647 
 
16648 
  def __init__(self, success=None, ex=None,):
16649 
    self.success = success
16650 
    self.ex = ex
16651 
 
16652 
  def read(self, iprot):
16653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16655 
      return
16656 
    iprot.readStructBegin()
16657 
    while True:
16658 
      (fname, ftype, fid) = iprot.readFieldBegin()
16659 
      if ftype == TType.STOP:
16660 
        break
16661 
      if fid == 0:
16662 
        if ftype == TType.MAP:
16663 
          self.success = {}
4586 mandeep.dh 16664 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16665 
          for _i279 in xrange(_size275):
16666 
            _key280 = iprot.readI32();
16667 
            _val281 = TimeoutSummary()
16668 
            _val281.read(iprot)
16669 
            self.success[_key280] = _val281
4369 rajveer 16670 
          iprot.readMapEnd()
16671 
        else:
16672 
          iprot.skip(ftype)
16673 
      elif fid == 1:
16674 
        if ftype == TType.STRUCT:
16675 
          self.ex = TransactionServiceException()
16676 
          self.ex.read(iprot)
16677 
        else:
16678 
          iprot.skip(ftype)
16679 
      else:
16680 
        iprot.skip(ftype)
16681 
      iprot.readFieldEnd()
16682 
    iprot.readStructEnd()
16683 
 
16684 
  def write(self, oprot):
16685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16687 
      return
16688 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16689 
    if self.success is not None:
16690 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16691 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16692 
      for kiter282,viter283 in self.success.items():
16693 
        oprot.writeI32(kiter282)
16694 
        viter283.write(oprot)
4369 rajveer 16695 
      oprot.writeMapEnd()
16696 
      oprot.writeFieldEnd()
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)
4386 anupam.sin 16718 
 
16719 
class getOrderForAwb_args:
16720 
  """
16721 
  Attributes:
16722 
   - awb
16723 
  """
16724 
 
16725 
  thrift_spec = (
16726 
    None, # 0
16727 
    (1, TType.STRING, 'awb', None, None, ), # 1
16728 
  )
16729 
 
16730 
  def __init__(self, awb=None,):
16731 
    self.awb = awb
16732 
 
16733 
  def read(self, iprot):
16734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16736 
      return
16737 
    iprot.readStructBegin()
16738 
    while True:
16739 
      (fname, ftype, fid) = iprot.readFieldBegin()
16740 
      if ftype == TType.STOP:
16741 
        break
16742 
      if fid == 1:
16743 
        if ftype == TType.STRING:
16744 
          self.awb = iprot.readString();
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
16756 
    oprot.writeStructBegin('getOrderForAwb_args')
16757 
    if self.awb is not None:
16758 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16759 
      oprot.writeString(self.awb)
16760 
      oprot.writeFieldEnd()
16761 
    oprot.writeFieldStop()
16762 
    oprot.writeStructEnd()
16763 
 
16764 
  def validate(self):
16765 
    return
16766 
 
16767 
 
16768 
  def __repr__(self):
16769 
    L = ['%s=%r' % (key, value)
16770 
      for key, value in self.__dict__.iteritems()]
16771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16772 
 
16773 
  def __eq__(self, other):
16774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16775 
 
16776 
  def __ne__(self, other):
16777 
    return not (self == other)
16778 
 
16779 
class getOrderForAwb_result:
16780 
  """
16781 
  Attributes:
16782 
   - success
16783 
   - ex
16784 
  """
16785 
 
16786 
  thrift_spec = (
16787 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16789 
  )
16790 
 
16791 
  def __init__(self, success=None, ex=None,):
16792 
    self.success = success
16793 
    self.ex = ex
16794 
 
16795 
  def read(self, iprot):
16796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16798 
      return
16799 
    iprot.readStructBegin()
16800 
    while True:
16801 
      (fname, ftype, fid) = iprot.readFieldBegin()
16802 
      if ftype == TType.STOP:
16803 
        break
16804 
      if fid == 0:
16805 
        if ftype == TType.STRUCT:
16806 
          self.success = Order()
16807 
          self.success.read(iprot)
16808 
        else:
16809 
          iprot.skip(ftype)
16810 
      elif fid == 1:
16811 
        if ftype == TType.STRUCT:
16812 
          self.ex = TransactionServiceException()
16813 
          self.ex.read(iprot)
16814 
        else:
16815 
          iprot.skip(ftype)
16816 
      else:
16817 
        iprot.skip(ftype)
16818 
      iprot.readFieldEnd()
16819 
    iprot.readStructEnd()
16820 
 
16821 
  def write(self, oprot):
16822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16824 
      return
16825 
    oprot.writeStructBegin('getOrderForAwb_result')
16826 
    if self.success is not None:
16827 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16828 
      self.success.write(oprot)
16829 
      oprot.writeFieldEnd()
16830 
    if self.ex is not None:
16831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16832 
      self.ex.write(oprot)
16833 
      oprot.writeFieldEnd()
16834 
    oprot.writeFieldStop()
16835 
    oprot.writeStructEnd()
16836 
 
16837 
  def validate(self):
16838 
    return
16839 
 
16840 
 
16841 
  def __repr__(self):
16842 
    L = ['%s=%r' % (key, value)
16843 
      for key, value in self.__dict__.iteritems()]
16844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16845 
 
16846 
  def __eq__(self, other):
16847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16848 
 
16849 
  def __ne__(self, other):
16850 
    return not (self == other)
4506 phani.kuma 16851 
 
16852 
class getOrdersForProviderForStatus_args:
16853 
  """
16854 
  Attributes:
16855 
   - logistics_provider_id
16856 
   - order_status
16857 
  """
16858 
 
16859 
  thrift_spec = (
16860 
    None, # 0
16861 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16862 
    (2, TType.I32, 'order_status', None, None, ), # 2
16863 
  )
16864 
 
16865 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16866 
    self.logistics_provider_id = logistics_provider_id
16867 
    self.order_status = order_status
16868 
 
16869 
  def read(self, iprot):
16870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16872 
      return
16873 
    iprot.readStructBegin()
16874 
    while True:
16875 
      (fname, ftype, fid) = iprot.readFieldBegin()
16876 
      if ftype == TType.STOP:
16877 
        break
16878 
      if fid == 1:
16879 
        if ftype == TType.I64:
16880 
          self.logistics_provider_id = iprot.readI64();
16881 
        else:
16882 
          iprot.skip(ftype)
16883 
      elif fid == 2:
16884 
        if ftype == TType.I32:
16885 
          self.order_status = iprot.readI32();
16886 
        else:
16887 
          iprot.skip(ftype)
16888 
      else:
16889 
        iprot.skip(ftype)
16890 
      iprot.readFieldEnd()
16891 
    iprot.readStructEnd()
16892 
 
16893 
  def write(self, oprot):
16894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16896 
      return
16897 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16898 
    if self.logistics_provider_id is not None:
16899 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16900 
      oprot.writeI64(self.logistics_provider_id)
16901 
      oprot.writeFieldEnd()
16902 
    if self.order_status is not None:
16903 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16904 
      oprot.writeI32(self.order_status)
16905 
      oprot.writeFieldEnd()
16906 
    oprot.writeFieldStop()
16907 
    oprot.writeStructEnd()
16908 
 
16909 
  def validate(self):
16910 
    return
16911 
 
16912 
 
16913 
  def __repr__(self):
16914 
    L = ['%s=%r' % (key, value)
16915 
      for key, value in self.__dict__.iteritems()]
16916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16917 
 
16918 
  def __eq__(self, other):
16919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16920 
 
16921 
  def __ne__(self, other):
16922 
    return not (self == other)
16923 
 
16924 
class getOrdersForProviderForStatus_result:
16925 
  """
16926 
  Attributes:
16927 
   - success
16928 
   - ex
16929 
  """
16930 
 
16931 
  thrift_spec = (
16932 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16934 
  )
16935 
 
16936 
  def __init__(self, success=None, ex=None,):
16937 
    self.success = success
16938 
    self.ex = ex
16939 
 
16940 
  def read(self, iprot):
16941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16943 
      return
16944 
    iprot.readStructBegin()
16945 
    while True:
16946 
      (fname, ftype, fid) = iprot.readFieldBegin()
16947 
      if ftype == TType.STOP:
16948 
        break
16949 
      if fid == 0:
16950 
        if ftype == TType.LIST:
16951 
          self.success = []
4586 mandeep.dh 16952 
          (_etype287, _size284) = iprot.readListBegin()
16953 
          for _i288 in xrange(_size284):
16954 
            _elem289 = Order()
16955 
            _elem289.read(iprot)
16956 
            self.success.append(_elem289)
4506 phani.kuma 16957 
          iprot.readListEnd()
16958 
        else:
16959 
          iprot.skip(ftype)
16960 
      elif fid == 1:
16961 
        if ftype == TType.STRUCT:
16962 
          self.ex = TransactionServiceException()
16963 
          self.ex.read(iprot)
16964 
        else:
16965 
          iprot.skip(ftype)
16966 
      else:
16967 
        iprot.skip(ftype)
16968 
      iprot.readFieldEnd()
16969 
    iprot.readStructEnd()
16970 
 
16971 
  def write(self, oprot):
16972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16974 
      return
16975 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16976 
    if self.success is not None:
16977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16978 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 16979 
      for iter290 in self.success:
16980 
        iter290.write(oprot)
4506 phani.kuma 16981 
      oprot.writeListEnd()
16982 
      oprot.writeFieldEnd()
16983 
    if self.ex is not None:
16984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16985 
      self.ex.write(oprot)
16986 
      oprot.writeFieldEnd()
16987 
    oprot.writeFieldStop()
16988 
    oprot.writeStructEnd()
16989 
 
16990 
  def validate(self):
16991 
    return
16992 
 
16993 
 
16994 
  def __repr__(self):
16995 
    L = ['%s=%r' % (key, value)
16996 
      for key, value in self.__dict__.iteritems()]
16997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16998 
 
16999 
  def __eq__(self, other):
17000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17001 
 
17002 
  def __ne__(self, other):
17003 
    return not (self == other)
4600 varun.gupt 17004 
 
17005 
class getBilledOrdersForVendor_args:
17006 
  """
17007 
  Attributes:
17008 
   - vendorId
17009 
   - billingDateFrom
17010 
   - billingDateTo
17011 
  """
17012 
 
17013 
  thrift_spec = (
17014 
    None, # 0
17015 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17016 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17017 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17018 
  )
17019 
 
17020 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17021 
    self.vendorId = vendorId
17022 
    self.billingDateFrom = billingDateFrom
17023 
    self.billingDateTo = billingDateTo
17024 
 
17025 
  def read(self, iprot):
17026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17028 
      return
17029 
    iprot.readStructBegin()
17030 
    while True:
17031 
      (fname, ftype, fid) = iprot.readFieldBegin()
17032 
      if ftype == TType.STOP:
17033 
        break
17034 
      if fid == 1:
17035 
        if ftype == TType.I64:
17036 
          self.vendorId = iprot.readI64();
17037 
        else:
17038 
          iprot.skip(ftype)
17039 
      elif fid == 2:
17040 
        if ftype == TType.I64:
17041 
          self.billingDateFrom = iprot.readI64();
17042 
        else:
17043 
          iprot.skip(ftype)
17044 
      elif fid == 3:
17045 
        if ftype == TType.I64:
17046 
          self.billingDateTo = iprot.readI64();
17047 
        else:
17048 
          iprot.skip(ftype)
17049 
      else:
17050 
        iprot.skip(ftype)
17051 
      iprot.readFieldEnd()
17052 
    iprot.readStructEnd()
17053 
 
17054 
  def write(self, oprot):
17055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17057 
      return
17058 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17059 
    if self.vendorId is not None:
17060 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17061 
      oprot.writeI64(self.vendorId)
17062 
      oprot.writeFieldEnd()
17063 
    if self.billingDateFrom is not None:
17064 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17065 
      oprot.writeI64(self.billingDateFrom)
17066 
      oprot.writeFieldEnd()
17067 
    if self.billingDateTo is not None:
17068 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17069 
      oprot.writeI64(self.billingDateTo)
17070 
      oprot.writeFieldEnd()
17071 
    oprot.writeFieldStop()
17072 
    oprot.writeStructEnd()
17073 
 
17074 
  def validate(self):
17075 
    return
17076 
 
17077 
 
17078 
  def __repr__(self):
17079 
    L = ['%s=%r' % (key, value)
17080 
      for key, value in self.__dict__.iteritems()]
17081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17082 
 
17083 
  def __eq__(self, other):
17084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17085 
 
17086 
  def __ne__(self, other):
17087 
    return not (self == other)
17088 
 
17089 
class getBilledOrdersForVendor_result:
17090 
  """
17091 
  Attributes:
17092 
   - success
17093 
   - ex
17094 
  """
17095 
 
17096 
  thrift_spec = (
17097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17099 
  )
17100 
 
17101 
  def __init__(self, success=None, ex=None,):
17102 
    self.success = success
17103 
    self.ex = ex
17104 
 
17105 
  def read(self, iprot):
17106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17108 
      return
17109 
    iprot.readStructBegin()
17110 
    while True:
17111 
      (fname, ftype, fid) = iprot.readFieldBegin()
17112 
      if ftype == TType.STOP:
17113 
        break
17114 
      if fid == 0:
17115 
        if ftype == TType.LIST:
17116 
          self.success = []
17117 
          (_etype294, _size291) = iprot.readListBegin()
17118 
          for _i295 in xrange(_size291):
17119 
            _elem296 = Order()
17120 
            _elem296.read(iprot)
17121 
            self.success.append(_elem296)
17122 
          iprot.readListEnd()
17123 
        else:
17124 
          iprot.skip(ftype)
17125 
      elif fid == 1:
17126 
        if ftype == TType.STRUCT:
17127 
          self.ex = TransactionServiceException()
17128 
          self.ex.read(iprot)
17129 
        else:
17130 
          iprot.skip(ftype)
17131 
      else:
17132 
        iprot.skip(ftype)
17133 
      iprot.readFieldEnd()
17134 
    iprot.readStructEnd()
17135 
 
17136 
  def write(self, oprot):
17137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17139 
      return
17140 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17141 
    if self.success is not None:
17142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17143 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17144 
      for iter297 in self.success:
17145 
        iter297.write(oprot)
17146 
      oprot.writeListEnd()
17147 
      oprot.writeFieldEnd()
17148 
    if self.ex is not None:
17149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17150 
      self.ex.write(oprot)
17151 
      oprot.writeFieldEnd()
17152 
    oprot.writeFieldStop()
17153 
    oprot.writeStructEnd()
17154 
 
17155 
  def validate(self):
17156 
    return
17157 
 
17158 
 
17159 
  def __repr__(self):
17160 
    L = ['%s=%r' % (key, value)
17161 
      for key, value in self.__dict__.iteritems()]
17162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17163 
 
17164 
  def __eq__(self, other):
17165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17166 
 
17167 
  def __ne__(self, other):
17168 
    return not (self == other)
17169 
 
4607 rajveer 17170 
class getSlippedSippingDateOrders_args:
17171 
 
17172 
  thrift_spec = (
17173 
  )
17174 
 
17175 
  def read(self, iprot):
17176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17178 
      return
17179 
    iprot.readStructBegin()
17180 
    while True:
17181 
      (fname, ftype, fid) = iprot.readFieldBegin()
17182 
      if ftype == TType.STOP:
17183 
        break
17184 
      else:
17185 
        iprot.skip(ftype)
17186 
      iprot.readFieldEnd()
17187 
    iprot.readStructEnd()
17188 
 
17189 
  def write(self, oprot):
17190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17192 
      return
17193 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17194 
    oprot.writeFieldStop()
17195 
    oprot.writeStructEnd()
17196 
 
17197 
  def validate(self):
17198 
    return
17199 
 
17200 
 
17201 
  def __repr__(self):
17202 
    L = ['%s=%r' % (key, value)
17203 
      for key, value in self.__dict__.iteritems()]
17204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17205 
 
17206 
  def __eq__(self, other):
17207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17208 
 
17209 
  def __ne__(self, other):
17210 
    return not (self == other)
17211 
 
17212 
class getSlippedSippingDateOrders_result:
17213 
  """
17214 
  Attributes:
17215 
   - success
17216 
   - ex
17217 
  """
17218 
 
17219 
  thrift_spec = (
17220 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17222 
  )
17223 
 
17224 
  def __init__(self, success=None, ex=None,):
17225 
    self.success = success
17226 
    self.ex = ex
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      if fid == 0:
17238 
        if ftype == TType.LIST:
17239 
          self.success = []
17240 
          (_etype301, _size298) = iprot.readListBegin()
17241 
          for _i302 in xrange(_size298):
17242 
            _elem303 = Order()
17243 
            _elem303.read(iprot)
17244 
            self.success.append(_elem303)
17245 
          iprot.readListEnd()
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      elif fid == 1:
17249 
        if ftype == TType.STRUCT:
17250 
          self.ex = TransactionServiceException()
17251 
          self.ex.read(iprot)
17252 
        else:
17253 
          iprot.skip(ftype)
17254 
      else:
17255 
        iprot.skip(ftype)
17256 
      iprot.readFieldEnd()
17257 
    iprot.readStructEnd()
17258 
 
17259 
  def write(self, oprot):
17260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17262 
      return
17263 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17264 
    if self.success is not None:
17265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17267 
      for iter304 in self.success:
17268 
        iter304.write(oprot)
17269 
      oprot.writeListEnd()
17270 
      oprot.writeFieldEnd()
17271 
    if self.ex is not None:
17272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17273 
      self.ex.write(oprot)
17274 
      oprot.writeFieldEnd()
17275 
    oprot.writeFieldStop()
17276 
    oprot.writeStructEnd()
17277 
 
17278 
  def validate(self):
17279 
    return
17280 
 
17281 
 
17282 
  def __repr__(self):
17283 
    L = ['%s=%r' % (key, value)
17284 
      for key, value in self.__dict__.iteritems()]
17285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17286 
 
17287 
  def __eq__(self, other):
17288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17289 
 
17290 
  def __ne__(self, other):
17291 
    return not (self == other)
17292 
 
4600 varun.gupt 17293 
class saveBluedartSettlements_args:
17294 
  """
17295 
  Attributes:
17296 
   - mapAWBAndAmount
17297 
  """
17298 
 
17299 
  thrift_spec = (
17300 
    None, # 0
17301 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17302 
  )
17303 
 
17304 
  def __init__(self, mapAWBAndAmount=None,):
17305 
    self.mapAWBAndAmount = mapAWBAndAmount
17306 
 
17307 
  def read(self, iprot):
17308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17310 
      return
17311 
    iprot.readStructBegin()
17312 
    while True:
17313 
      (fname, ftype, fid) = iprot.readFieldBegin()
17314 
      if ftype == TType.STOP:
17315 
        break
17316 
      if fid == 1:
17317 
        if ftype == TType.MAP:
17318 
          self.mapAWBAndAmount = {}
4607 rajveer 17319 
          (_ktype306, _vtype307, _size305 ) = iprot.readMapBegin()
17320 
          for _i309 in xrange(_size305):
17321 
            _key310 = iprot.readI64();
17322 
            _val311 = iprot.readDouble();
17323 
            self.mapAWBAndAmount[_key310] = _val311
4600 varun.gupt 17324 
          iprot.readMapEnd()
17325 
        else:
17326 
          iprot.skip(ftype)
17327 
      else:
17328 
        iprot.skip(ftype)
17329 
      iprot.readFieldEnd()
17330 
    iprot.readStructEnd()
17331 
 
17332 
  def write(self, oprot):
17333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17335 
      return
17336 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17337 
    if self.mapAWBAndAmount is not None:
17338 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17339 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4607 rajveer 17340 
      for kiter312,viter313 in self.mapAWBAndAmount.items():
17341 
        oprot.writeI64(kiter312)
17342 
        oprot.writeDouble(viter313)
4600 varun.gupt 17343 
      oprot.writeMapEnd()
17344 
      oprot.writeFieldEnd()
17345 
    oprot.writeFieldStop()
17346 
    oprot.writeStructEnd()
17347 
 
17348 
  def validate(self):
17349 
    return
17350 
 
17351 
 
17352 
  def __repr__(self):
17353 
    L = ['%s=%r' % (key, value)
17354 
      for key, value in self.__dict__.iteritems()]
17355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17356 
 
17357 
  def __eq__(self, other):
17358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17359 
 
17360 
  def __ne__(self, other):
17361 
    return not (self == other)
17362 
 
17363 
class saveBluedartSettlements_result:
17364 
  """
17365 
  Attributes:
17366 
   - ex
17367 
  """
17368 
 
17369 
  thrift_spec = (
17370 
    None, # 0
17371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17372 
  )
17373 
 
17374 
  def __init__(self, ex=None,):
17375 
    self.ex = ex
17376 
 
17377 
  def read(self, iprot):
17378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17380 
      return
17381 
    iprot.readStructBegin()
17382 
    while True:
17383 
      (fname, ftype, fid) = iprot.readFieldBegin()
17384 
      if ftype == TType.STOP:
17385 
        break
17386 
      if fid == 1:
17387 
        if ftype == TType.STRUCT:
17388 
          self.ex = TransactionServiceException()
17389 
          self.ex.read(iprot)
17390 
        else:
17391 
          iprot.skip(ftype)
17392 
      else:
17393 
        iprot.skip(ftype)
17394 
      iprot.readFieldEnd()
17395 
    iprot.readStructEnd()
17396 
 
17397 
  def write(self, oprot):
17398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17400 
      return
17401 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17402 
    if self.ex is not None:
17403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17404 
      self.ex.write(oprot)
17405 
      oprot.writeFieldEnd()
17406 
    oprot.writeFieldStop()
17407 
    oprot.writeStructEnd()
17408 
 
17409 
  def validate(self):
17410 
    return
17411 
 
17412 
 
17413 
  def __repr__(self):
17414 
    L = ['%s=%r' % (key, value)
17415 
      for key, value in self.__dict__.iteritems()]
17416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17417 
 
17418 
  def __eq__(self, other):
17419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17420 
 
17421 
  def __ne__(self, other):
17422 
    return not (self == other)
17423 
 
17424 
class savePaymentSettlements_args:
17425 
  """
17426 
  Attributes:
17427 
   - settlementDate
17428 
   - paymentGatewayId
17429 
   - paymentId
17430 
   - serviceTax
17431 
   - otherCharges
17432 
   - netCollection
17433 
  """
17434 
 
17435 
  thrift_spec = (
17436 
    None, # 0
17437 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17438 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17439 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17440 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17441 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17442 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17443 
  )
17444 
 
17445 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17446 
    self.settlementDate = settlementDate
17447 
    self.paymentGatewayId = paymentGatewayId
17448 
    self.paymentId = paymentId
17449 
    self.serviceTax = serviceTax
17450 
    self.otherCharges = otherCharges
17451 
    self.netCollection = netCollection
17452 
 
17453 
  def read(self, iprot):
17454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17456 
      return
17457 
    iprot.readStructBegin()
17458 
    while True:
17459 
      (fname, ftype, fid) = iprot.readFieldBegin()
17460 
      if ftype == TType.STOP:
17461 
        break
17462 
      if fid == 1:
17463 
        if ftype == TType.I64:
17464 
          self.settlementDate = iprot.readI64();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      elif fid == 2:
17468 
        if ftype == TType.I64:
17469 
          self.paymentGatewayId = iprot.readI64();
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 3:
17473 
        if ftype == TType.I64:
17474 
          self.paymentId = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      elif fid == 4:
17478 
        if ftype == TType.DOUBLE:
17479 
          self.serviceTax = iprot.readDouble();
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      elif fid == 5:
17483 
        if ftype == TType.DOUBLE:
17484 
          self.otherCharges = iprot.readDouble();
17485 
        else:
17486 
          iprot.skip(ftype)
17487 
      elif fid == 6:
17488 
        if ftype == TType.DOUBLE:
17489 
          self.netCollection = iprot.readDouble();
17490 
        else:
17491 
          iprot.skip(ftype)
17492 
      else:
17493 
        iprot.skip(ftype)
17494 
      iprot.readFieldEnd()
17495 
    iprot.readStructEnd()
17496 
 
17497 
  def write(self, oprot):
17498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17500 
      return
17501 
    oprot.writeStructBegin('savePaymentSettlements_args')
17502 
    if self.settlementDate is not None:
17503 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17504 
      oprot.writeI64(self.settlementDate)
17505 
      oprot.writeFieldEnd()
17506 
    if self.paymentGatewayId is not None:
17507 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17508 
      oprot.writeI64(self.paymentGatewayId)
17509 
      oprot.writeFieldEnd()
17510 
    if self.paymentId is not None:
17511 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17512 
      oprot.writeI64(self.paymentId)
17513 
      oprot.writeFieldEnd()
17514 
    if self.serviceTax is not None:
17515 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17516 
      oprot.writeDouble(self.serviceTax)
17517 
      oprot.writeFieldEnd()
17518 
    if self.otherCharges is not None:
17519 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17520 
      oprot.writeDouble(self.otherCharges)
17521 
      oprot.writeFieldEnd()
17522 
    if self.netCollection is not None:
17523 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17524 
      oprot.writeDouble(self.netCollection)
17525 
      oprot.writeFieldEnd()
17526 
    oprot.writeFieldStop()
17527 
    oprot.writeStructEnd()
17528 
 
17529 
  def validate(self):
17530 
    return
17531 
 
17532 
 
17533 
  def __repr__(self):
17534 
    L = ['%s=%r' % (key, value)
17535 
      for key, value in self.__dict__.iteritems()]
17536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17537 
 
17538 
  def __eq__(self, other):
17539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17540 
 
17541 
  def __ne__(self, other):
17542 
    return not (self == other)
17543 
 
17544 
class savePaymentSettlements_result:
17545 
  """
17546 
  Attributes:
17547 
   - ex
17548 
  """
17549 
 
17550 
  thrift_spec = (
17551 
    None, # 0
17552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17553 
  )
17554 
 
17555 
  def __init__(self, ex=None,):
17556 
    self.ex = ex
17557 
 
17558 
  def read(self, iprot):
17559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17561 
      return
17562 
    iprot.readStructBegin()
17563 
    while True:
17564 
      (fname, ftype, fid) = iprot.readFieldBegin()
17565 
      if ftype == TType.STOP:
17566 
        break
17567 
      if fid == 1:
17568 
        if ftype == TType.STRUCT:
17569 
          self.ex = TransactionServiceException()
17570 
          self.ex.read(iprot)
17571 
        else:
17572 
          iprot.skip(ftype)
17573 
      else:
17574 
        iprot.skip(ftype)
17575 
      iprot.readFieldEnd()
17576 
    iprot.readStructEnd()
17577 
 
17578 
  def write(self, oprot):
17579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17581 
      return
17582 
    oprot.writeStructBegin('savePaymentSettlements_result')
17583 
    if self.ex is not None:
17584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17585 
      self.ex.write(oprot)
17586 
      oprot.writeFieldEnd()
17587 
    oprot.writeFieldStop()
17588 
    oprot.writeStructEnd()
17589 
 
17590 
  def validate(self):
17591 
    return
17592 
 
17593 
 
17594 
  def __repr__(self):
17595 
    L = ['%s=%r' % (key, value)
17596 
      for key, value in self.__dict__.iteritems()]
17597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17598 
 
17599 
  def __eq__(self, other):
17600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17601 
 
17602 
  def __ne__(self, other):
17603 
    return not (self == other)
17604 
 
17605 
class saveEBSSettlementSummary_args:
17606 
  """
17607 
  Attributes:
17608 
   - settlementId
17609 
   - settlementDate
17610 
   - transactionDateFrom
17611 
   - transactionDateTo
17612 
   - amount
17613 
  """
17614 
 
17615 
  thrift_spec = (
17616 
    None, # 0
17617 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17618 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
17619 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
17620 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
17621 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
17622 
  )
17623 
 
17624 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
17625 
    self.settlementId = settlementId
17626 
    self.settlementDate = settlementDate
17627 
    self.transactionDateFrom = transactionDateFrom
17628 
    self.transactionDateTo = transactionDateTo
17629 
    self.amount = amount
17630 
 
17631 
  def read(self, iprot):
17632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17634 
      return
17635 
    iprot.readStructBegin()
17636 
    while True:
17637 
      (fname, ftype, fid) = iprot.readFieldBegin()
17638 
      if ftype == TType.STOP:
17639 
        break
17640 
      if fid == 1:
17641 
        if ftype == TType.I64:
17642 
          self.settlementId = iprot.readI64();
17643 
        else:
17644 
          iprot.skip(ftype)
17645 
      elif fid == 2:
17646 
        if ftype == TType.I64:
17647 
          self.settlementDate = iprot.readI64();
17648 
        else:
17649 
          iprot.skip(ftype)
17650 
      elif fid == 3:
17651 
        if ftype == TType.I64:
17652 
          self.transactionDateFrom = iprot.readI64();
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      elif fid == 4:
17656 
        if ftype == TType.I64:
17657 
          self.transactionDateTo = iprot.readI64();
17658 
        else:
17659 
          iprot.skip(ftype)
17660 
      elif fid == 5:
17661 
        if ftype == TType.DOUBLE:
17662 
          self.amount = iprot.readDouble();
17663 
        else:
17664 
          iprot.skip(ftype)
17665 
      else:
17666 
        iprot.skip(ftype)
17667 
      iprot.readFieldEnd()
17668 
    iprot.readStructEnd()
17669 
 
17670 
  def write(self, oprot):
17671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17673 
      return
17674 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
17675 
    if self.settlementId is not None:
17676 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17677 
      oprot.writeI64(self.settlementId)
17678 
      oprot.writeFieldEnd()
17679 
    if self.settlementDate is not None:
17680 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
17681 
      oprot.writeI64(self.settlementDate)
17682 
      oprot.writeFieldEnd()
17683 
    if self.transactionDateFrom is not None:
17684 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
17685 
      oprot.writeI64(self.transactionDateFrom)
17686 
      oprot.writeFieldEnd()
17687 
    if self.transactionDateTo is not None:
17688 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
17689 
      oprot.writeI64(self.transactionDateTo)
17690 
      oprot.writeFieldEnd()
17691 
    if self.amount is not None:
17692 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
17693 
      oprot.writeDouble(self.amount)
17694 
      oprot.writeFieldEnd()
17695 
    oprot.writeFieldStop()
17696 
    oprot.writeStructEnd()
17697 
 
17698 
  def validate(self):
17699 
    return
17700 
 
17701 
 
17702 
  def __repr__(self):
17703 
    L = ['%s=%r' % (key, value)
17704 
      for key, value in self.__dict__.iteritems()]
17705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17706 
 
17707 
  def __eq__(self, other):
17708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17709 
 
17710 
  def __ne__(self, other):
17711 
    return not (self == other)
17712 
 
17713 
class saveEBSSettlementSummary_result:
17714 
  """
17715 
  Attributes:
17716 
   - ex
17717 
  """
17718 
 
17719 
  thrift_spec = (
17720 
    None, # 0
17721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17722 
  )
17723 
 
17724 
  def __init__(self, ex=None,):
17725 
    self.ex = ex
17726 
 
17727 
  def read(self, iprot):
17728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17730 
      return
17731 
    iprot.readStructBegin()
17732 
    while True:
17733 
      (fname, ftype, fid) = iprot.readFieldBegin()
17734 
      if ftype == TType.STOP:
17735 
        break
17736 
      if fid == 1:
17737 
        if ftype == TType.STRUCT:
17738 
          self.ex = TransactionServiceException()
17739 
          self.ex.read(iprot)
17740 
        else:
17741 
          iprot.skip(ftype)
17742 
      else:
17743 
        iprot.skip(ftype)
17744 
      iprot.readFieldEnd()
17745 
    iprot.readStructEnd()
17746 
 
17747 
  def write(self, oprot):
17748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17750 
      return
17751 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
17752 
    if self.ex is not None:
17753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17754 
      self.ex.write(oprot)
17755 
      oprot.writeFieldEnd()
17756 
    oprot.writeFieldStop()
17757 
    oprot.writeStructEnd()
17758 
 
17759 
  def validate(self):
17760 
    return
17761 
 
17762 
 
17763 
  def __repr__(self):
17764 
    L = ['%s=%r' % (key, value)
17765 
      for key, value in self.__dict__.iteritems()]
17766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17767 
 
17768 
  def __eq__(self, other):
17769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17770 
 
17771 
  def __ne__(self, other):
17772 
    return not (self == other)
17773 
 
17774 
class getSettlementForPaymentId_args:
17775 
  """
17776 
  Attributes:
17777 
   - paymentId
17778 
  """
17779 
 
17780 
  thrift_spec = (
17781 
    None, # 0
17782 
    (1, TType.I64, 'paymentId', None, None, ), # 1
17783 
  )
17784 
 
17785 
  def __init__(self, paymentId=None,):
17786 
    self.paymentId = paymentId
17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 1:
17798 
        if ftype == TType.I64:
17799 
          self.paymentId = iprot.readI64();
17800 
        else:
17801 
          iprot.skip(ftype)
17802 
      else:
17803 
        iprot.skip(ftype)
17804 
      iprot.readFieldEnd()
17805 
    iprot.readStructEnd()
17806 
 
17807 
  def write(self, oprot):
17808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17810 
      return
17811 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
17812 
    if self.paymentId is not None:
17813 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
17814 
      oprot.writeI64(self.paymentId)
17815 
      oprot.writeFieldEnd()
17816 
    oprot.writeFieldStop()
17817 
    oprot.writeStructEnd()
17818 
 
17819 
  def validate(self):
17820 
    return
17821 
 
17822 
 
17823 
  def __repr__(self):
17824 
    L = ['%s=%r' % (key, value)
17825 
      for key, value in self.__dict__.iteritems()]
17826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17827 
 
17828 
  def __eq__(self, other):
17829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17830 
 
17831 
  def __ne__(self, other):
17832 
    return not (self == other)
17833 
 
17834 
class getSettlementForPaymentId_result:
17835 
  """
17836 
  Attributes:
17837 
   - success
17838 
   - ex
17839 
  """
17840 
 
17841 
  thrift_spec = (
17842 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
17843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17844 
  )
17845 
 
17846 
  def __init__(self, success=None, ex=None,):
17847 
    self.success = success
17848 
    self.ex = ex
17849 
 
17850 
  def read(self, iprot):
17851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17853 
      return
17854 
    iprot.readStructBegin()
17855 
    while True:
17856 
      (fname, ftype, fid) = iprot.readFieldBegin()
17857 
      if ftype == TType.STOP:
17858 
        break
17859 
      if fid == 0:
17860 
        if ftype == TType.STRUCT:
17861 
          self.success = PaymentSettlement()
17862 
          self.success.read(iprot)
17863 
        else:
17864 
          iprot.skip(ftype)
17865 
      elif fid == 1:
17866 
        if ftype == TType.STRUCT:
17867 
          self.ex = TransactionServiceException()
17868 
          self.ex.read(iprot)
17869 
        else:
17870 
          iprot.skip(ftype)
17871 
      else:
17872 
        iprot.skip(ftype)
17873 
      iprot.readFieldEnd()
17874 
    iprot.readStructEnd()
17875 
 
17876 
  def write(self, oprot):
17877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17879 
      return
17880 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
17881 
    if self.success is not None:
17882 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17883 
      self.success.write(oprot)
17884 
      oprot.writeFieldEnd()
17885 
    if self.ex is not None:
17886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17887 
      self.ex.write(oprot)
17888 
      oprot.writeFieldEnd()
17889 
    oprot.writeFieldStop()
17890 
    oprot.writeStructEnd()
17891 
 
17892 
  def validate(self):
17893 
    return
17894 
 
17895 
 
17896 
  def __repr__(self):
17897 
    L = ['%s=%r' % (key, value)
17898 
      for key, value in self.__dict__.iteritems()]
17899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17900 
 
17901 
  def __eq__(self, other):
17902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17903 
 
17904 
  def __ne__(self, other):
17905 
    return not (self == other)
17906 
 
17907 
class getEBSSettlementSummaries_args:
17908 
 
17909 
  thrift_spec = (
17910 
  )
17911 
 
17912 
  def read(self, iprot):
17913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17915 
      return
17916 
    iprot.readStructBegin()
17917 
    while True:
17918 
      (fname, ftype, fid) = iprot.readFieldBegin()
17919 
      if ftype == TType.STOP:
17920 
        break
17921 
      else:
17922 
        iprot.skip(ftype)
17923 
      iprot.readFieldEnd()
17924 
    iprot.readStructEnd()
17925 
 
17926 
  def write(self, oprot):
17927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17929 
      return
17930 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
17931 
    oprot.writeFieldStop()
17932 
    oprot.writeStructEnd()
17933 
 
17934 
  def validate(self):
17935 
    return
17936 
 
17937 
 
17938 
  def __repr__(self):
17939 
    L = ['%s=%r' % (key, value)
17940 
      for key, value in self.__dict__.iteritems()]
17941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17942 
 
17943 
  def __eq__(self, other):
17944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17945 
 
17946 
  def __ne__(self, other):
17947 
    return not (self == other)
17948 
 
17949 
class getEBSSettlementSummaries_result:
17950 
  """
17951 
  Attributes:
17952 
   - success
17953 
   - ex
17954 
  """
17955 
 
17956 
  thrift_spec = (
17957 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
17958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17959 
  )
17960 
 
17961 
  def __init__(self, success=None, ex=None,):
17962 
    self.success = success
17963 
    self.ex = ex
17964 
 
17965 
  def read(self, iprot):
17966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17968 
      return
17969 
    iprot.readStructBegin()
17970 
    while True:
17971 
      (fname, ftype, fid) = iprot.readFieldBegin()
17972 
      if ftype == TType.STOP:
17973 
        break
17974 
      if fid == 0:
17975 
        if ftype == TType.MAP:
17976 
          self.success = {}
4607 rajveer 17977 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
17978 
          for _i318 in xrange(_size314):
17979 
            _key319 = iprot.readI64();
17980 
            _val320 = iprot.readString();
17981 
            self.success[_key319] = _val320
4600 varun.gupt 17982 
          iprot.readMapEnd()
17983 
        else:
17984 
          iprot.skip(ftype)
17985 
      elif fid == 1:
17986 
        if ftype == TType.STRUCT:
17987 
          self.ex = TransactionServiceException()
17988 
          self.ex.read(iprot)
17989 
        else:
17990 
          iprot.skip(ftype)
17991 
      else:
17992 
        iprot.skip(ftype)
17993 
      iprot.readFieldEnd()
17994 
    iprot.readStructEnd()
17995 
 
17996 
  def write(self, oprot):
17997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17999 
      return
18000 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18001 
    if self.success is not None:
18002 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18003 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4607 rajveer 18004 
      for kiter321,viter322 in self.success.items():
18005 
        oprot.writeI64(kiter321)
18006 
        oprot.writeString(viter322)
4600 varun.gupt 18007 
      oprot.writeMapEnd()
18008 
      oprot.writeFieldEnd()
18009 
    if self.ex is not None:
18010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18011 
      self.ex.write(oprot)
18012 
      oprot.writeFieldEnd()
18013 
    oprot.writeFieldStop()
18014 
    oprot.writeStructEnd()
18015 
 
18016 
  def validate(self):
18017 
    return
18018 
 
18019 
 
18020 
  def __repr__(self):
18021 
    L = ['%s=%r' % (key, value)
18022 
      for key, value in self.__dict__.iteritems()]
18023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18024 
 
18025 
  def __eq__(self, other):
18026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18027 
 
18028 
  def __ne__(self, other):
18029 
    return not (self == other)
18030 
 
18031 
class markEBSSettlementUploaded_args:
18032 
  """
18033 
  Attributes:
18034 
   - settlementId
18035 
  """
18036 
 
18037 
  thrift_spec = (
18038 
    None, # 0
18039 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18040 
  )
18041 
 
18042 
  def __init__(self, settlementId=None,):
18043 
    self.settlementId = settlementId
18044 
 
18045 
  def read(self, iprot):
18046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18048 
      return
18049 
    iprot.readStructBegin()
18050 
    while True:
18051 
      (fname, ftype, fid) = iprot.readFieldBegin()
18052 
      if ftype == TType.STOP:
18053 
        break
18054 
      if fid == 1:
18055 
        if ftype == TType.I64:
18056 
          self.settlementId = iprot.readI64();
18057 
        else:
18058 
          iprot.skip(ftype)
18059 
      else:
18060 
        iprot.skip(ftype)
18061 
      iprot.readFieldEnd()
18062 
    iprot.readStructEnd()
18063 
 
18064 
  def write(self, oprot):
18065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18067 
      return
18068 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18069 
    if self.settlementId is not None:
18070 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18071 
      oprot.writeI64(self.settlementId)
18072 
      oprot.writeFieldEnd()
18073 
    oprot.writeFieldStop()
18074 
    oprot.writeStructEnd()
18075 
 
18076 
  def validate(self):
18077 
    return
18078 
 
18079 
 
18080 
  def __repr__(self):
18081 
    L = ['%s=%r' % (key, value)
18082 
      for key, value in self.__dict__.iteritems()]
18083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18084 
 
18085 
  def __eq__(self, other):
18086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18087 
 
18088 
  def __ne__(self, other):
18089 
    return not (self == other)
18090 
 
18091 
class markEBSSettlementUploaded_result:
18092 
  """
18093 
  Attributes:
18094 
   - ex
18095 
  """
18096 
 
18097 
  thrift_spec = (
18098 
    None, # 0
18099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18100 
  )
18101 
 
18102 
  def __init__(self, ex=None,):
18103 
    self.ex = ex
18104 
 
18105 
  def read(self, iprot):
18106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18108 
      return
18109 
    iprot.readStructBegin()
18110 
    while True:
18111 
      (fname, ftype, fid) = iprot.readFieldBegin()
18112 
      if ftype == TType.STOP:
18113 
        break
18114 
      if fid == 1:
18115 
        if ftype == TType.STRUCT:
18116 
          self.ex = TransactionServiceException()
18117 
          self.ex.read(iprot)
18118 
        else:
18119 
          iprot.skip(ftype)
18120 
      else:
18121 
        iprot.skip(ftype)
18122 
      iprot.readFieldEnd()
18123 
    iprot.readStructEnd()
18124 
 
18125 
  def write(self, oprot):
18126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18128 
      return
18129 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18130 
    if self.ex is not None:
18131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18132 
      self.ex.write(oprot)
18133 
      oprot.writeFieldEnd()
18134 
    oprot.writeFieldStop()
18135 
    oprot.writeStructEnd()
18136 
 
18137 
  def validate(self):
18138 
    return
18139 
 
18140 
 
18141 
  def __repr__(self):
18142 
    L = ['%s=%r' % (key, value)
18143 
      for key, value in self.__dict__.iteritems()]
18144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18145 
 
18146 
  def __eq__(self, other):
18147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18148 
 
18149 
  def __ne__(self, other):
18150 
    return not (self == other)
18151 
 
18152 
class getEBSSettlementDate_args:
18153 
  """
18154 
  Attributes:
18155 
   - settlementId
18156 
  """
18157 
 
18158 
  thrift_spec = (
18159 
    None, # 0
18160 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18161 
  )
18162 
 
18163 
  def __init__(self, settlementId=None,):
18164 
    self.settlementId = settlementId
18165 
 
18166 
  def read(self, iprot):
18167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18169 
      return
18170 
    iprot.readStructBegin()
18171 
    while True:
18172 
      (fname, ftype, fid) = iprot.readFieldBegin()
18173 
      if ftype == TType.STOP:
18174 
        break
18175 
      if fid == 1:
18176 
        if ftype == TType.I64:
18177 
          self.settlementId = iprot.readI64();
18178 
        else:
18179 
          iprot.skip(ftype)
18180 
      else:
18181 
        iprot.skip(ftype)
18182 
      iprot.readFieldEnd()
18183 
    iprot.readStructEnd()
18184 
 
18185 
  def write(self, oprot):
18186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18188 
      return
18189 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18190 
    if self.settlementId is not None:
18191 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18192 
      oprot.writeI64(self.settlementId)
18193 
      oprot.writeFieldEnd()
18194 
    oprot.writeFieldStop()
18195 
    oprot.writeStructEnd()
18196 
 
18197 
  def validate(self):
18198 
    return
18199 
 
18200 
 
18201 
  def __repr__(self):
18202 
    L = ['%s=%r' % (key, value)
18203 
      for key, value in self.__dict__.iteritems()]
18204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18205 
 
18206 
  def __eq__(self, other):
18207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18208 
 
18209 
  def __ne__(self, other):
18210 
    return not (self == other)
18211 
 
18212 
class getEBSSettlementDate_result:
18213 
  """
18214 
  Attributes:
18215 
   - success
18216 
   - ex
18217 
  """
18218 
 
18219 
  thrift_spec = (
18220 
    (0, TType.I64, 'success', None, None, ), # 0
18221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18222 
  )
18223 
 
18224 
  def __init__(self, success=None, ex=None,):
18225 
    self.success = success
18226 
    self.ex = ex
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 == 0:
18238 
        if ftype == TType.I64:
18239 
          self.success = iprot.readI64();
18240 
        else:
18241 
          iprot.skip(ftype)
18242 
      elif fid == 1:
18243 
        if ftype == TType.STRUCT:
18244 
          self.ex = TransactionServiceException()
18245 
          self.ex.read(iprot)
18246 
        else:
18247 
          iprot.skip(ftype)
18248 
      else:
18249 
        iprot.skip(ftype)
18250 
      iprot.readFieldEnd()
18251 
    iprot.readStructEnd()
18252 
 
18253 
  def write(self, oprot):
18254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18256 
      return
18257 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18258 
    if self.success is not None:
18259 
      oprot.writeFieldBegin('success', TType.I64, 0)
18260 
      oprot.writeI64(self.success)
18261 
      oprot.writeFieldEnd()
18262 
    if self.ex is not None:
18263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18264 
      self.ex.write(oprot)
18265 
      oprot.writeFieldEnd()
18266 
    oprot.writeFieldStop()
18267 
    oprot.writeStructEnd()
18268 
 
18269 
  def validate(self):
18270 
    return
18271 
 
18272 
 
18273 
  def __repr__(self):
18274 
    L = ['%s=%r' % (key, value)
18275 
      for key, value in self.__dict__.iteritems()]
18276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18277 
 
18278 
  def __eq__(self, other):
18279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18280 
 
18281 
  def __ne__(self, other):
18282 
    return not (self == other)