Subversion Repositories SmartDukaan

Rev

Rev 4658 | Rev 4709 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4658 mandeep.dh 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
435 
    Returns the final flag status.
436 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
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 
 
4662 rajveer 871 
  def markOrderAsLostInTransit(self, orderId):
872 
    """
873 
    Mark order as LOST_IN_TRANSIT
874 
 
875 
    Parameters:
876 
     - orderId
877 
    """
878 
    pass
879 
 
4386 anupam.sin 880 
  def getOrderForAwb(self, awb):
881 
    """
882 
    Returns the order corresponding to an AWB number
4369 rajveer 883 
 
4386 anupam.sin 884 
    Parameters:
885 
     - awb
886 
    """
887 
    pass
888 
 
4506 phani.kuma 889 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
890 
    """
891 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 892 
 
4506 phani.kuma 893 
    Parameters:
894 
     - logistics_provider_id
895 
     - order_status
896 
    """
897 
    pass
898 
 
4600 varun.gupt 899 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
900 
    """
901 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 902 
 
4600 varun.gupt 903 
    Parameters:
904 
     - vendorId
905 
     - billingDateFrom
906 
     - billingDateTo
907 
    """
908 
    pass
909 
 
4607 rajveer 910 
  def getSlippedSippingDateOrders(self, ):
911 
    pass
912 
 
4600 varun.gupt 913 
  def saveBluedartSettlements(self, mapAWBAndAmount):
914 
    """
915 
    Parameters:
916 
     - mapAWBAndAmount
917 
    """
918 
    pass
919 
 
920 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
921 
    """
922 
    Parameters:
923 
     - settlementDate
924 
     - paymentGatewayId
925 
     - paymentId
926 
     - serviceTax
927 
     - otherCharges
928 
     - netCollection
929 
    """
930 
    pass
931 
 
932 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
933 
    """
934 
    Parameters:
935 
     - settlementId
936 
     - settlementDate
937 
     - transactionDateFrom
938 
     - transactionDateTo
939 
     - amount
940 
    """
941 
    pass
942 
 
943 
  def getSettlementForPaymentId(self, paymentId):
944 
    """
945 
    Parameters:
946 
     - paymentId
947 
    """
948 
    pass
949 
 
950 
  def getEBSSettlementSummaries(self, ):
951 
    pass
952 
 
953 
  def markEBSSettlementUploaded(self, settlementId):
954 
    """
955 
    Parameters:
956 
     - settlementId
957 
    """
958 
    pass
959 
 
960 
  def getEBSSettlementDate(self, settlementId):
961 
    """
962 
    Parameters:
963 
     - settlementId
964 
    """
965 
    pass
966 
 
967 
 
3376 rajveer 968 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 969 
  def __init__(self, iprot, oprot=None):
3376 rajveer 970 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 971 
 
972 
  def createTransaction(self, transaction):
973 
    """
974 
    Parameters:
975 
     - transaction
976 
    """
977 
    self.send_createTransaction(transaction)
132 ashish 978 
    return self.recv_createTransaction()
94 ashish 979 
 
980 
  def send_createTransaction(self, transaction):
981 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
982 
    args = createTransaction_args()
983 
    args.transaction = transaction
984 
    args.write(self._oprot)
985 
    self._oprot.writeMessageEnd()
986 
    self._oprot.trans.flush()
987 
 
988 
  def recv_createTransaction(self, ):
989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
990 
    if mtype == TMessageType.EXCEPTION:
991 
      x = TApplicationException()
992 
      x.read(self._iprot)
993 
      self._iprot.readMessageEnd()
994 
      raise x
995 
    result = createTransaction_result()
996 
    result.read(self._iprot)
997 
    self._iprot.readMessageEnd()
3431 rajveer 998 
    if result.success is not None:
132 ashish 999 
      return result.success
3431 rajveer 1000 
    if result.ex is not None:
94 ashish 1001 
      raise result.ex
132 ashish 1002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1003 
 
1004 
  def getTransaction(self, id):
1005 
    """
1006 
    Parameters:
1007 
     - id
1008 
    """
1009 
    self.send_getTransaction(id)
1010 
    return self.recv_getTransaction()
1011 
 
1012 
  def send_getTransaction(self, id):
1013 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1014 
    args = getTransaction_args()
1015 
    args.id = id
1016 
    args.write(self._oprot)
1017 
    self._oprot.writeMessageEnd()
1018 
    self._oprot.trans.flush()
1019 
 
1020 
  def recv_getTransaction(self, ):
1021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1022 
    if mtype == TMessageType.EXCEPTION:
1023 
      x = TApplicationException()
1024 
      x.read(self._iprot)
1025 
      self._iprot.readMessageEnd()
1026 
      raise x
1027 
    result = getTransaction_result()
1028 
    result.read(self._iprot)
1029 
    self._iprot.readMessageEnd()
3431 rajveer 1030 
    if result.success is not None:
94 ashish 1031 
      return result.success
3431 rajveer 1032 
    if result.ex is not None:
94 ashish 1033 
      raise result.ex
1034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1035 
 
1036 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1037 
    """
1038 
    Parameters:
1039 
     - customerId
1040 
     - from_date
1041 
     - to_date
1042 
     - status
1043 
    """
1044 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1045 
    return self.recv_getTransactionsForCustomer()
1046 
 
1047 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1048 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1049 
    args = getTransactionsForCustomer_args()
1050 
    args.customerId = customerId
1051 
    args.from_date = from_date
1052 
    args.to_date = to_date
1053 
    args.status = status
1054 
    args.write(self._oprot)
1055 
    self._oprot.writeMessageEnd()
1056 
    self._oprot.trans.flush()
1057 
 
1058 
  def recv_getTransactionsForCustomer(self, ):
1059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1060 
    if mtype == TMessageType.EXCEPTION:
1061 
      x = TApplicationException()
1062 
      x.read(self._iprot)
1063 
      self._iprot.readMessageEnd()
1064 
      raise x
1065 
    result = getTransactionsForCustomer_result()
1066 
    result.read(self._iprot)
1067 
    self._iprot.readMessageEnd()
3431 rajveer 1068 
    if result.success is not None:
94 ashish 1069 
      return result.success
3431 rajveer 1070 
    if result.ex is not None:
94 ashish 1071 
      raise result.ex
1072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1073 
 
132 ashish 1074 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1075 
    """
1076 
    Parameters:
1077 
     - shoppingCartId
1078 
    """
1079 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1080 
    return self.recv_getTransactionsForShoppingCartId()
1081 
 
1082 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1083 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1084 
    args = getTransactionsForShoppingCartId_args()
1085 
    args.shoppingCartId = shoppingCartId
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_getTransactionsForShoppingCartId(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = getTransactionsForShoppingCartId_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
3431 rajveer 1100 
    if result.success is not None:
132 ashish 1101 
      return result.success
3431 rajveer 1102 
    if result.ex is not None:
132 ashish 1103 
      raise result.ex
1104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1105 
 
94 ashish 1106 
  def getTransactionStatus(self, transactionId):
1107 
    """
1108 
    Parameters:
1109 
     - transactionId
1110 
    """
1111 
    self.send_getTransactionStatus(transactionId)
1112 
    return self.recv_getTransactionStatus()
1113 
 
1114 
  def send_getTransactionStatus(self, transactionId):
1115 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1116 
    args = getTransactionStatus_args()
1117 
    args.transactionId = transactionId
1118 
    args.write(self._oprot)
1119 
    self._oprot.writeMessageEnd()
1120 
    self._oprot.trans.flush()
1121 
 
1122 
  def recv_getTransactionStatus(self, ):
1123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1124 
    if mtype == TMessageType.EXCEPTION:
1125 
      x = TApplicationException()
1126 
      x.read(self._iprot)
1127 
      self._iprot.readMessageEnd()
1128 
      raise x
1129 
    result = getTransactionStatus_result()
1130 
    result.read(self._iprot)
1131 
    self._iprot.readMessageEnd()
3431 rajveer 1132 
    if result.success is not None:
94 ashish 1133 
      return result.success
3431 rajveer 1134 
    if result.ex is not None:
94 ashish 1135 
      raise result.ex
1136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1137 
 
1138 
  def changeTransactionStatus(self, transactionId, status, description):
1139 
    """
1140 
    Parameters:
1141 
     - transactionId
1142 
     - status
1143 
     - description
1144 
    """
1145 
    self.send_changeTransactionStatus(transactionId, status, description)
1146 
    return self.recv_changeTransactionStatus()
1147 
 
1148 
  def send_changeTransactionStatus(self, transactionId, status, description):
1149 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1150 
    args = changeTransactionStatus_args()
1151 
    args.transactionId = transactionId
1152 
    args.status = status
1153 
    args.description = description
1154 
    args.write(self._oprot)
1155 
    self._oprot.writeMessageEnd()
1156 
    self._oprot.trans.flush()
1157 
 
1158 
  def recv_changeTransactionStatus(self, ):
1159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1160 
    if mtype == TMessageType.EXCEPTION:
1161 
      x = TApplicationException()
1162 
      x.read(self._iprot)
1163 
      self._iprot.readMessageEnd()
1164 
      raise x
1165 
    result = changeTransactionStatus_result()
1166 
    result.read(self._iprot)
1167 
    self._iprot.readMessageEnd()
3431 rajveer 1168 
    if result.success is not None:
94 ashish 1169 
      return result.success
3431 rajveer 1170 
    if result.ex is not None:
94 ashish 1171 
      raise result.ex
1172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1173 
 
1398 varun.gupt 1174 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1175 
    """
1176 
    Parameters:
1177 
     - transactionId
1178 
    """
1398 varun.gupt 1179 
    self.send_enqueueTransactionInfoEmail(transactionId)
1180 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1181 
 
1398 varun.gupt 1182 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1183 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1184 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1185 
    args.transactionId = transactionId
1186 
    args.write(self._oprot)
1187 
    self._oprot.writeMessageEnd()
1188 
    self._oprot.trans.flush()
1189 
 
1398 varun.gupt 1190 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1192 
    if mtype == TMessageType.EXCEPTION:
1193 
      x = TApplicationException()
1194 
      x.read(self._iprot)
1195 
      self._iprot.readMessageEnd()
1196 
      raise x
1398 varun.gupt 1197 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1198 
    result.read(self._iprot)
1199 
    self._iprot.readMessageEnd()
3431 rajveer 1200 
    if result.success is not None:
1382 varun.gupt 1201 
      return result.success
3431 rajveer 1202 
    if result.ex is not None:
1382 varun.gupt 1203 
      raise result.ex
1398 varun.gupt 1204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1205 
 
483 rajveer 1206 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1207 
    """
1208 
    Parameters:
483 rajveer 1209 
     - status
1210 
     - from_date
1211 
     - to_date
1212 
     - warehouse_id
94 ashish 1213 
    """
483 rajveer 1214 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1215 
    return self.recv_getAllOrders()
94 ashish 1216 
 
483 rajveer 1217 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1218 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1219 
    args = getAllOrders_args()
1220 
    args.status = status
1221 
    args.from_date = from_date
1222 
    args.to_date = to_date
1223 
    args.warehouse_id = warehouse_id
94 ashish 1224 
    args.write(self._oprot)
1225 
    self._oprot.writeMessageEnd()
1226 
    self._oprot.trans.flush()
1227 
 
483 rajveer 1228 
  def recv_getAllOrders(self, ):
94 ashish 1229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1230 
    if mtype == TMessageType.EXCEPTION:
1231 
      x = TApplicationException()
1232 
      x.read(self._iprot)
1233 
      self._iprot.readMessageEnd()
1234 
      raise x
483 rajveer 1235 
    result = getAllOrders_result()
94 ashish 1236 
    result.read(self._iprot)
1237 
    self._iprot.readMessageEnd()
3431 rajveer 1238 
    if result.success is not None:
94 ashish 1239 
      return result.success
3431 rajveer 1240 
    if result.ex is not None:
94 ashish 1241 
      raise result.ex
483 rajveer 1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1243 
 
4133 chandransh 1244 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1245 
    """
1246 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1247 
    Pass the status as null and the limit as 0 to ignore them.
1248 
 
1249 
    Parameters:
1250 
     - statuses
1251 
     - offset
1252 
     - limit
1253 
     - warehouse_id
1254 
    """
1255 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1256 
    return self.recv_getOrdersInBatch()
1257 
 
1258 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1259 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1260 
    args = getOrdersInBatch_args()
1261 
    args.statuses = statuses
1262 
    args.offset = offset
1263 
    args.limit = limit
1264 
    args.warehouse_id = warehouse_id
1265 
    args.write(self._oprot)
1266 
    self._oprot.writeMessageEnd()
1267 
    self._oprot.trans.flush()
1268 
 
1269 
  def recv_getOrdersInBatch(self, ):
1270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1271 
    if mtype == TMessageType.EXCEPTION:
1272 
      x = TApplicationException()
1273 
      x.read(self._iprot)
1274 
      self._iprot.readMessageEnd()
1275 
      raise x
1276 
    result = getOrdersInBatch_result()
1277 
    result.read(self._iprot)
1278 
    self._iprot.readMessageEnd()
1279 
    if result.success is not None:
1280 
      return result.success
1281 
    if result.ex is not None:
1282 
      raise result.ex
1283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1284 
 
1285 
  def getOrderCount(self, statuses, warehouseId):
1286 
    """
1287 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1288 
 
1289 
    Parameters:
1290 
     - statuses
1291 
     - warehouseId
1292 
    """
1293 
    self.send_getOrderCount(statuses, warehouseId)
1294 
    return self.recv_getOrderCount()
1295 
 
1296 
  def send_getOrderCount(self, statuses, warehouseId):
1297 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1298 
    args = getOrderCount_args()
1299 
    args.statuses = statuses
1300 
    args.warehouseId = warehouseId
1301 
    args.write(self._oprot)
1302 
    self._oprot.writeMessageEnd()
1303 
    self._oprot.trans.flush()
1304 
 
1305 
  def recv_getOrderCount(self, ):
1306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1307 
    if mtype == TMessageType.EXCEPTION:
1308 
      x = TApplicationException()
1309 
      x.read(self._iprot)
1310 
      self._iprot.readMessageEnd()
1311 
      raise x
1312 
    result = getOrderCount_result()
1313 
    result.read(self._iprot)
1314 
    self._iprot.readMessageEnd()
1315 
    if result.success is not None:
1316 
      return result.success
1317 
    if result.ex is not None:
1318 
      raise result.ex
1319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1320 
 
999 varun.gupt 1321 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1322 
    """
1132 chandransh 1323 
    Returns orders within a range of their billing dates
3431 rajveer 1324 
 
999 varun.gupt 1325 
    Parameters:
1326 
     - status
1327 
     - start_billing_date
1328 
     - end_billing_date
1329 
     - warehouse_id
1330 
    """
1331 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1332 
    return self.recv_getOrdersByBillingDate()
1333 
 
1334 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1335 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1336 
    args = getOrdersByBillingDate_args()
1337 
    args.status = status
1338 
    args.start_billing_date = start_billing_date
1339 
    args.end_billing_date = end_billing_date
1340 
    args.warehouse_id = warehouse_id
1341 
    args.write(self._oprot)
1342 
    self._oprot.writeMessageEnd()
1343 
    self._oprot.trans.flush()
1344 
 
1345 
  def recv_getOrdersByBillingDate(self, ):
1346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1347 
    if mtype == TMessageType.EXCEPTION:
1348 
      x = TApplicationException()
1349 
      x.read(self._iprot)
1350 
      self._iprot.readMessageEnd()
1351 
      raise x
1352 
    result = getOrdersByBillingDate_result()
1353 
    result.read(self._iprot)
1354 
    self._iprot.readMessageEnd()
3431 rajveer 1355 
    if result.success is not None:
999 varun.gupt 1356 
      return result.success
3431 rajveer 1357 
    if result.ex is not None:
999 varun.gupt 1358 
      raise result.ex
1359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1360 
 
3451 chandransh 1361 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1362 
    """
1363 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1364 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1365 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1366 
 
3427 chandransh 1367 
    Parameters:
1368 
     - fromShippingDate
1369 
     - toShippingDate
1370 
     - providerId
1371 
     - warehouseId
3451 chandransh 1372 
     - cod
3427 chandransh 1373 
    """
3451 chandransh 1374 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1375 
    return self.recv_getOrdersByShippingDate()
1376 
 
3451 chandransh 1377 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1378 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1379 
    args = getOrdersByShippingDate_args()
1380 
    args.fromShippingDate = fromShippingDate
1381 
    args.toShippingDate = toShippingDate
1382 
    args.providerId = providerId
1383 
    args.warehouseId = warehouseId
3451 chandransh 1384 
    args.cod = cod
3427 chandransh 1385 
    args.write(self._oprot)
1386 
    self._oprot.writeMessageEnd()
1387 
    self._oprot.trans.flush()
1388 
 
1389 
  def recv_getOrdersByShippingDate(self, ):
1390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1391 
    if mtype == TMessageType.EXCEPTION:
1392 
      x = TApplicationException()
1393 
      x.read(self._iprot)
1394 
      self._iprot.readMessageEnd()
1395 
      raise x
1396 
    result = getOrdersByShippingDate_result()
1397 
    result.read(self._iprot)
1398 
    self._iprot.readMessageEnd()
3431 rajveer 1399 
    if result.success is not None:
3427 chandransh 1400 
      return result.success
3431 rajveer 1401 
    if result.ex is not None:
3427 chandransh 1402 
      raise result.ex
1403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1404 
 
1382 varun.gupt 1405 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1406 
    """
1407 
    Returns order ids for orders which can be returned
3431 rajveer 1408 
 
1382 varun.gupt 1409 
    Parameters:
1410 
     - customer_id
1411 
     - limit
1412 
    """
1413 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1414 
    return self.recv_getReturnableOrdersForCustomer()
1415 
 
1416 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1417 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1418 
    args = getReturnableOrdersForCustomer_args()
1419 
    args.customer_id = customer_id
1420 
    args.limit = limit
1421 
    args.write(self._oprot)
1422 
    self._oprot.writeMessageEnd()
1423 
    self._oprot.trans.flush()
1424 
 
1425 
  def recv_getReturnableOrdersForCustomer(self, ):
1426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1427 
    if mtype == TMessageType.EXCEPTION:
1428 
      x = TApplicationException()
1429 
      x.read(self._iprot)
1430 
      self._iprot.readMessageEnd()
1431 
      raise x
1432 
    result = getReturnableOrdersForCustomer_result()
1433 
    result.read(self._iprot)
1434 
    self._iprot.readMessageEnd()
3431 rajveer 1435 
    if result.success is not None:
1382 varun.gupt 1436 
      return result.success
3431 rajveer 1437 
    if result.ex is not None:
1382 varun.gupt 1438 
      raise result.ex
1439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1440 
 
1441 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1442 
    """
1443 
    Returns order ids for orders which can be cancelled
3431 rajveer 1444 
 
1382 varun.gupt 1445 
    Parameters:
1446 
     - customer_id
1447 
     - limit
1448 
    """
1449 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1450 
    return self.recv_getCancellableOrdersForCustomer()
1451 
 
1452 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1453 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1454 
    args = getCancellableOrdersForCustomer_args()
1455 
    args.customer_id = customer_id
1456 
    args.limit = limit
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getCancellableOrdersForCustomer(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getCancellableOrdersForCustomer_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
3431 rajveer 1471 
    if result.success is not None:
1382 varun.gupt 1472 
      return result.success
3431 rajveer 1473 
    if result.ex is not None:
1382 varun.gupt 1474 
      raise result.ex
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1476 
 
483 rajveer 1477 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1478 
    """
1479 
    Parameters:
483 rajveer 1480 
     - orderId
1481 
     - status
1482 
     - description
94 ashish 1483 
    """
483 rajveer 1484 
    self.send_changeOrderStatus(orderId, status, description)
1485 
    return self.recv_changeOrderStatus()
94 ashish 1486 
 
483 rajveer 1487 
  def send_changeOrderStatus(self, orderId, status, description):
1488 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1489 
    args = changeOrderStatus_args()
1490 
    args.orderId = orderId
1491 
    args.status = status
1492 
    args.description = description
94 ashish 1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
483 rajveer 1497 
  def recv_changeOrderStatus(self, ):
94 ashish 1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
483 rajveer 1504 
    result = changeOrderStatus_result()
94 ashish 1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
94 ashish 1508 
      return result.success
3431 rajveer 1509 
    if result.ex is not None:
94 ashish 1510 
      raise result.ex
483 rajveer 1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1512 
 
1528 ankur.sing 1513 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1514 
    """
1528 ankur.sing 1515 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1516 
    only user who owns the transaction can view its order details.
3431 rajveer 1517 
 
94 ashish 1518 
    Parameters:
1519 
     - transactionId
1528 ankur.sing 1520 
     - customerId
94 ashish 1521 
    """
1528 ankur.sing 1522 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1523 
    return self.recv_getOrdersForTransaction()
94 ashish 1524 
 
1528 ankur.sing 1525 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1526 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1527 
    args = getOrdersForTransaction_args()
94 ashish 1528 
    args.transactionId = transactionId
1528 ankur.sing 1529 
    args.customerId = customerId
94 ashish 1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
483 rajveer 1534 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
483 rajveer 1541 
    result = getOrdersForTransaction_result()
94 ashish 1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
3431 rajveer 1544 
    if result.success is not None:
94 ashish 1545 
      return result.success
3431 rajveer 1546 
    if result.ex is not None:
94 ashish 1547 
      raise result.ex
483 rajveer 1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1549 
 
3014 chandransh 1550 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1551 
    """
3014 chandransh 1552 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1553 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1554 
 
94 ashish 1555 
    Parameters:
483 rajveer 1556 
     - customerId
1557 
     - from_date
1558 
     - to_date
3014 chandransh 1559 
     - statuses
94 ashish 1560 
    """
3014 chandransh 1561 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1562 
    return self.recv_getOrdersForCustomer()
94 ashish 1563 
 
3014 chandransh 1564 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1565 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1566 
    args = getOrdersForCustomer_args()
1567 
    args.customerId = customerId
1568 
    args.from_date = from_date
1569 
    args.to_date = to_date
3014 chandransh 1570 
    args.statuses = statuses
94 ashish 1571 
    args.write(self._oprot)
1572 
    self._oprot.writeMessageEnd()
1573 
    self._oprot.trans.flush()
1574 
 
483 rajveer 1575 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1577 
    if mtype == TMessageType.EXCEPTION:
1578 
      x = TApplicationException()
1579 
      x.read(self._iprot)
1580 
      self._iprot.readMessageEnd()
1581 
      raise x
483 rajveer 1582 
    result = getOrdersForCustomer_result()
94 ashish 1583 
    result.read(self._iprot)
1584 
    self._iprot.readMessageEnd()
3431 rajveer 1585 
    if result.success is not None:
94 ashish 1586 
      return result.success
3431 rajveer 1587 
    if result.ex is not None:
94 ashish 1588 
      raise result.ex
483 rajveer 1589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1590 
 
483 rajveer 1591 
  def createOrder(self, order):
94 ashish 1592 
    """
1593 
    Parameters:
483 rajveer 1594 
     - order
94 ashish 1595 
    """
483 rajveer 1596 
    self.send_createOrder(order)
1597 
    return self.recv_createOrder()
94 ashish 1598 
 
483 rajveer 1599 
  def send_createOrder(self, order):
1600 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1601 
    args = createOrder_args()
1602 
    args.order = order
94 ashish 1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
483 rajveer 1607 
  def recv_createOrder(self, ):
94 ashish 1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
483 rajveer 1614 
    result = createOrder_result()
94 ashish 1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
3431 rajveer 1617 
    if result.success is not None:
94 ashish 1618 
      return result.success
3431 rajveer 1619 
    if result.ex is not None:
94 ashish 1620 
      raise result.ex
483 rajveer 1621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1622 
 
483 rajveer 1623 
  def getOrder(self, id):
94 ashish 1624 
    """
1625 
    Parameters:
483 rajveer 1626 
     - id
94 ashish 1627 
    """
483 rajveer 1628 
    self.send_getOrder(id)
1629 
    return self.recv_getOrder()
94 ashish 1630 
 
483 rajveer 1631 
  def send_getOrder(self, id):
1632 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1633 
    args = getOrder_args()
1634 
    args.id = id
94 ashish 1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
483 rajveer 1639 
  def recv_getOrder(self, ):
94 ashish 1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
483 rajveer 1646 
    result = getOrder_result()
94 ashish 1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
3431 rajveer 1649 
    if result.success is not None:
94 ashish 1650 
      return result.success
3431 rajveer 1651 
    if result.ex is not None:
94 ashish 1652 
      raise result.ex
483 rajveer 1653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1654 
 
483 rajveer 1655 
  def getLineItemsForOrder(self, orderId):
94 ashish 1656 
    """
1657 
    Parameters:
483 rajveer 1658 
     - orderId
94 ashish 1659 
    """
483 rajveer 1660 
    self.send_getLineItemsForOrder(orderId)
1661 
    return self.recv_getLineItemsForOrder()
94 ashish 1662 
 
483 rajveer 1663 
  def send_getLineItemsForOrder(self, orderId):
1664 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1665 
    args = getLineItemsForOrder_args()
1666 
    args.orderId = orderId
94 ashish 1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
483 rajveer 1671 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
483 rajveer 1678 
    result = getLineItemsForOrder_result()
94 ashish 1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
3431 rajveer 1681 
    if result.success is not None:
94 ashish 1682 
      return result.success
3431 rajveer 1683 
    if result.ex is not None:
94 ashish 1684 
      raise result.ex
483 rajveer 1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1686 
 
1528 ankur.sing 1687 
  def getOrderForCustomer(self, orderId, customerId):
1688 
    """
1689 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1690 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1691 
 
1528 ankur.sing 1692 
    Parameters:
1693 
     - orderId
1694 
     - customerId
1695 
    """
1696 
    self.send_getOrderForCustomer(orderId, customerId)
1697 
    return self.recv_getOrderForCustomer()
1698 
 
1699 
  def send_getOrderForCustomer(self, orderId, customerId):
1700 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1701 
    args = getOrderForCustomer_args()
1702 
    args.orderId = orderId
1703 
    args.customerId = customerId
1704 
    args.write(self._oprot)
1705 
    self._oprot.writeMessageEnd()
1706 
    self._oprot.trans.flush()
1707 
 
1708 
  def recv_getOrderForCustomer(self, ):
1709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1710 
    if mtype == TMessageType.EXCEPTION:
1711 
      x = TApplicationException()
1712 
      x.read(self._iprot)
1713 
      self._iprot.readMessageEnd()
1714 
      raise x
1715 
    result = getOrderForCustomer_result()
1716 
    result.read(self._iprot)
1717 
    self._iprot.readMessageEnd()
3431 rajveer 1718 
    if result.success is not None:
1528 ankur.sing 1719 
      return result.success
3431 rajveer 1720 
    if result.ex is not None:
1528 ankur.sing 1721 
      raise result.ex
1722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1723 
 
4444 rajveer 1724 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1725 
    """
1726 
    Parameters:
4394 rajveer 1727 
     - type
4444 rajveer 1728 
     - warehouseId
4394 rajveer 1729 
     - status
1730 
     - timestamp
3064 chandransh 1731 
    """
4444 rajveer 1732 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1733 
    return self.recv_getAlerts()
1734 
 
4444 rajveer 1735 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1736 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1737 
    args = getAlerts_args()
4394 rajveer 1738 
    args.type = type
4444 rajveer 1739 
    args.warehouseId = warehouseId
4394 rajveer 1740 
    args.status = status
1741 
    args.timestamp = timestamp
3064 chandransh 1742 
    args.write(self._oprot)
1743 
    self._oprot.writeMessageEnd()
1744 
    self._oprot.trans.flush()
1745 
 
1746 
  def recv_getAlerts(self, ):
1747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1748 
    if mtype == TMessageType.EXCEPTION:
1749 
      x = TApplicationException()
1750 
      x.read(self._iprot)
1751 
      self._iprot.readMessageEnd()
1752 
      raise x
1753 
    result = getAlerts_result()
1754 
    result.read(self._iprot)
1755 
    self._iprot.readMessageEnd()
3431 rajveer 1756 
    if result.success is not None:
3064 chandransh 1757 
      return result.success
1758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1759 
 
4444 rajveer 1760 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1761 
    """
1762 
    Parameters:
1763 
     - type
4444 rajveer 1764 
     - warehouseId
4394 rajveer 1765 
     - description
3064 chandransh 1766 
    """
4444 rajveer 1767 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1768 
    self.recv_addAlert()
3064 chandransh 1769 
 
4444 rajveer 1770 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1771 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1772 
    args = addAlert_args()
3064 chandransh 1773 
    args.type = type
4444 rajveer 1774 
    args.warehouseId = warehouseId
4394 rajveer 1775 
    args.description = description
3064 chandransh 1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
4394 rajveer 1780 
  def recv_addAlert(self, ):
3064 chandransh 1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
4394 rajveer 1787 
    result = addAlert_result()
3064 chandransh 1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
1790 
    return
1791 
 
4444 rajveer 1792 
  def markAlertsAsSeen(self, warehouseId):
1793 
    """
1794 
    Parameters:
1795 
     - warehouseId
1796 
    """
1797 
    self.send_markAlertsAsSeen(warehouseId)
1798 
    self.recv_markAlertsAsSeen()
1799 
 
1800 
  def send_markAlertsAsSeen(self, warehouseId):
1801 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1802 
    args = markAlertsAsSeen_args()
1803 
    args.warehouseId = warehouseId
1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
1808 
  def recv_markAlertsAsSeen(self, ):
1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
1815 
    result = markAlertsAsSeen_result()
1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
1818 
    return
1819 
 
3064 chandransh 1820 
  def getValidOrderCount(self, ):
1821 
    """
1822 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1823 
    """
1824 
    self.send_getValidOrderCount()
1825 
    return self.recv_getValidOrderCount()
1826 
 
1827 
  def send_getValidOrderCount(self, ):
1828 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1829 
    args = getValidOrderCount_args()
1830 
    args.write(self._oprot)
1831 
    self._oprot.writeMessageEnd()
1832 
    self._oprot.trans.flush()
1833 
 
1834 
  def recv_getValidOrderCount(self, ):
1835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1836 
    if mtype == TMessageType.EXCEPTION:
1837 
      x = TApplicationException()
1838 
      x.read(self._iprot)
1839 
      self._iprot.readMessageEnd()
1840 
      raise x
1841 
    result = getValidOrderCount_result()
1842 
    result.read(self._iprot)
1843 
    self._iprot.readMessageEnd()
3431 rajveer 1844 
    if result.success is not None:
3064 chandransh 1845 
      return result.success
1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1847 
 
1848 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1849 
    """
1850 
    Returns the number of distinct customers who have done successful transactions
1851 
    """
1852 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1853 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1854 
 
1855 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1856 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1857 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
3431 rajveer 1872 
    if result.success is not None:
3064 chandransh 1873 
      return result.success
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1875 
 
1876 
  def getValidOrdersAmountRange(self, ):
1877 
    """
1878 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1879 
    List contains two values, first minimum amount and second maximum amount.
1880 
    """
1881 
    self.send_getValidOrdersAmountRange()
1882 
    return self.recv_getValidOrdersAmountRange()
1883 
 
1884 
  def send_getValidOrdersAmountRange(self, ):
1885 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1886 
    args = getValidOrdersAmountRange_args()
1887 
    args.write(self._oprot)
1888 
    self._oprot.writeMessageEnd()
1889 
    self._oprot.trans.flush()
1890 
 
1891 
  def recv_getValidOrdersAmountRange(self, ):
1892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1893 
    if mtype == TMessageType.EXCEPTION:
1894 
      x = TApplicationException()
1895 
      x.read(self._iprot)
1896 
      self._iprot.readMessageEnd()
1897 
      raise x
1898 
    result = getValidOrdersAmountRange_result()
1899 
    result.read(self._iprot)
1900 
    self._iprot.readMessageEnd()
3431 rajveer 1901 
    if result.success is not None:
3064 chandransh 1902 
      return result.success
1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1904 
 
1905 
  def getValidOrders(self, limit):
1906 
    """
1907 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1908 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1909 
 
3064 chandransh 1910 
    Parameters:
1911 
     - limit
1912 
    """
1913 
    self.send_getValidOrders(limit)
1914 
    return self.recv_getValidOrders()
1915 
 
1916 
  def send_getValidOrders(self, limit):
1917 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1918 
    args = getValidOrders_args()
1919 
    args.limit = limit
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_getValidOrders(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = getValidOrders_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
3431 rajveer 1934 
    if result.success is not None:
3064 chandransh 1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1937 
 
1220 chandransh 1938 
  def batchOrders(self, warehouseId):
1939 
    """
1940 
    Create a batch of all the pending orders for the given warehouse.
1941 
    The returned list is orderd by created_timestamp.
1942 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1943 
 
1220 chandransh 1944 
    Parameters:
1945 
     - warehouseId
1946 
    """
1947 
    self.send_batchOrders(warehouseId)
1948 
    return self.recv_batchOrders()
1949 
 
1950 
  def send_batchOrders(self, warehouseId):
1951 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1952 
    args = batchOrders_args()
1953 
    args.warehouseId = warehouseId
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_batchOrders(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = batchOrders_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
3431 rajveer 1968 
    if result.success is not None:
1220 chandransh 1969 
      return result.success
3431 rajveer 1970 
    if result.ex is not None:
1220 chandransh 1971 
      raise result.ex
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1973 
 
1208 chandransh 1974 
  def markOrderAsOutOfStock(self, orderId):
1975 
    """
1976 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1977 
 
1208 chandransh 1978 
    Parameters:
1979 
     - orderId
1980 
    """
1981 
    self.send_markOrderAsOutOfStock(orderId)
1982 
    return self.recv_markOrderAsOutOfStock()
1983 
 
1984 
  def send_markOrderAsOutOfStock(self, orderId):
1985 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1986 
    args = markOrderAsOutOfStock_args()
1987 
    args.orderId = orderId
1988 
    args.write(self._oprot)
1989 
    self._oprot.writeMessageEnd()
1990 
    self._oprot.trans.flush()
1991 
 
1992 
  def recv_markOrderAsOutOfStock(self, ):
1993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1994 
    if mtype == TMessageType.EXCEPTION:
1995 
      x = TApplicationException()
1996 
      x.read(self._iprot)
1997 
      self._iprot.readMessageEnd()
1998 
      raise x
1999 
    result = markOrderAsOutOfStock_result()
2000 
    result.read(self._iprot)
2001 
    self._iprot.readMessageEnd()
3431 rajveer 2002 
    if result.success is not None:
1208 chandransh 2003 
      return result.success
3431 rajveer 2004 
    if result.ex is not None:
1208 chandransh 2005 
      raise result.ex
2006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2007 
 
3064 chandransh 2008 
  def verifyOrder(self, orderId):
759 chandransh 2009 
    """
3064 chandransh 2010 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2011 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2012 
    used for all other orders as well.
2013 
    Throws an exception if no such order exists.
3431 rajveer 2014 
 
759 chandransh 2015 
    Parameters:
3064 chandransh 2016 
     - orderId
759 chandransh 2017 
    """
3064 chandransh 2018 
    self.send_verifyOrder(orderId)
2019 
    return self.recv_verifyOrder()
759 chandransh 2020 
 
3064 chandransh 2021 
  def send_verifyOrder(self, orderId):
2022 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2023 
    args = verifyOrder_args()
2024 
    args.orderId = orderId
759 chandransh 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
3064 chandransh 2029 
  def recv_verifyOrder(self, ):
759 chandransh 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
3064 chandransh 2036 
    result = verifyOrder_result()
759 chandransh 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
759 chandransh 2040 
      return result.success
3431 rajveer 2041 
    if result.ex is not None:
759 chandransh 2042 
      raise result.ex
3064 chandransh 2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2044 
 
3064 chandransh 2045 
  def acceptOrder(self, orderId):
1113 chandransh 2046 
    """
3064 chandransh 2047 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2048 
    given order is not a COD order, it also captures the payment if the same has
2049 
    not been captured.
2050 
    Throws an exception if no such order exists.
3431 rajveer 2051 
 
1113 chandransh 2052 
    Parameters:
3064 chandransh 2053 
     - orderId
1113 chandransh 2054 
    """
3064 chandransh 2055 
    self.send_acceptOrder(orderId)
2056 
    return self.recv_acceptOrder()
1113 chandransh 2057 
 
3064 chandransh 2058 
  def send_acceptOrder(self, orderId):
2059 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2060 
    args = acceptOrder_args()
2061 
    args.orderId = orderId
1113 chandransh 2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
3064 chandransh 2066 
  def recv_acceptOrder(self, ):
1113 chandransh 2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
3064 chandransh 2073 
    result = acceptOrder_result()
1113 chandransh 2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
3431 rajveer 2076 
    if result.success is not None:
1113 chandransh 2077 
      return result.success
3431 rajveer 2078 
    if result.ex is not None:
1113 chandransh 2079 
      raise result.ex
3064 chandransh 2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2081 
 
4658 mandeep.dh 2082 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2083 
    """
3064 chandransh 2084 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2085 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2086 
    the IMEI no. if a -1 is supplied.
2087 
    Also, it generates an invoice number for the order, marks the order as
2088 
    BILLED and sets the billing timestamp.
2089 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2090 
 
1135 chandransh 2091 
    Parameters:
3064 chandransh 2092 
     - orderId
2093 
     - invoice_number
4658 mandeep.dh 2094 
     - serialNumber
4283 anupam.sin 2095 
     - itemNumber
3064 chandransh 2096 
     - billed_by
4264 rajveer 2097 
     - jacketNumber
4283 anupam.sin 2098 
     - billingType
2099 
     - vendorId
1135 chandransh 2100 
    """
4658 mandeep.dh 2101 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2102 
    return self.recv_addBillingDetails()
1135 chandransh 2103 
 
4658 mandeep.dh 2104 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2105 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2106 
    args = addBillingDetails_args()
2107 
    args.orderId = orderId
2108 
    args.invoice_number = invoice_number
4658 mandeep.dh 2109 
    args.serialNumber = serialNumber
4283 anupam.sin 2110 
    args.itemNumber = itemNumber
3064 chandransh 2111 
    args.billed_by = billed_by
4264 rajveer 2112 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2113 
    args.billingType = billingType
2114 
    args.vendorId = vendorId
1135 chandransh 2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
3064 chandransh 2119 
  def recv_addBillingDetails(self, ):
1135 chandransh 2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
3064 chandransh 2126 
    result = addBillingDetails_result()
1135 chandransh 2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
3064 chandransh 2130 
      return result.success
3431 rajveer 2131 
    if result.ex is not None:
1135 chandransh 2132 
      raise result.ex
3064 chandransh 2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2134 
 
4579 rajveer 2135 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2136 
    """
2137 
    Add the invoice number to the order.
2138 
 
2139 
    Parameters:
2140 
     - orderId
2141 
     - invoiceNumber
2142 
    """
2143 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2144 
    self.recv_addInvoiceNumber()
2145 
 
2146 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2147 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2148 
    args = addInvoiceNumber_args()
2149 
    args.orderId = orderId
2150 
    args.invoiceNumber = invoiceNumber
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_addInvoiceNumber(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = addInvoiceNumber_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.ex is not None:
2166 
      raise result.ex
2167 
    return
2168 
 
3064 chandransh 2169 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2170 
    """
3064 chandransh 2171 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2172 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2173 
 
1408 ankur.sing 2174 
    Parameters:
3064 chandransh 2175 
     - warehouseId
1408 ankur.sing 2176 
     - providerId
3064 chandransh 2177 
     - cod
1408 ankur.sing 2178 
    """
3064 chandransh 2179 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2180 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2181 
 
3064 chandransh 2182 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2183 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2184 
    args = markOrdersAsManifested_args()
2185 
    args.warehouseId = warehouseId
1408 ankur.sing 2186 
    args.providerId = providerId
3064 chandransh 2187 
    args.cod = cod
1408 ankur.sing 2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
3064 chandransh 2192 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2194 
    if mtype == TMessageType.EXCEPTION:
2195 
      x = TApplicationException()
2196 
      x.read(self._iprot)
2197 
      self._iprot.readMessageEnd()
2198 
      raise x
3064 chandransh 2199 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
3431 rajveer 2202 
    if result.success is not None:
1408 ankur.sing 2203 
      return result.success
3431 rajveer 2204 
    if result.ex is not None:
3064 chandransh 2205 
      raise result.ex
2206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2207 
 
4410 rajveer 2208 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2209 
    """
2210 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2211 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2212 
 
2213 
    Parameters:
2214 
     - warehouseId
2215 
     - providerId
2216 
     - cod
2217 
    """
2218 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2219 
    return self.recv_markOrdersAsShippedFromWarehouse()
2220 
 
2221 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2222 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2223 
    args = markOrdersAsShippedFromWarehouse_args()
2224 
    args.warehouseId = warehouseId
2225 
    args.providerId = providerId
2226 
    args.cod = cod
2227 
    args.write(self._oprot)
2228 
    self._oprot.writeMessageEnd()
2229 
    self._oprot.trans.flush()
2230 
 
2231 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2233 
    if mtype == TMessageType.EXCEPTION:
2234 
      x = TApplicationException()
2235 
      x.read(self._iprot)
2236 
      self._iprot.readMessageEnd()
2237 
      raise x
2238 
    result = markOrdersAsShippedFromWarehouse_result()
2239 
    result.read(self._iprot)
2240 
    self._iprot.readMessageEnd()
2241 
    if result.success is not None:
2242 
      return result.success
2243 
    if result.ex is not None:
2244 
      raise result.ex
2245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2246 
 
3064 chandransh 2247 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2248 
    """
3064 chandransh 2249 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2250 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2251 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2252 
 
94 ashish 2253 
    Parameters:
3064 chandransh 2254 
     - providerId
2255 
     - pickupDetails
304 ashish 2256 
    """
3064 chandransh 2257 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2258 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2259 
 
3064 chandransh 2260 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2261 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2262 
    args = markOrdersAsPickedUp_args()
2263 
    args.providerId = providerId
2264 
    args.pickupDetails = pickupDetails
304 ashish 2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
3064 chandransh 2269 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
3064 chandransh 2276 
    result = markOrdersAsPickedUp_result()
304 ashish 2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
3431 rajveer 2279 
    if result.success is not None:
304 ashish 2280 
      return result.success
3431 rajveer 2281 
    if result.ex is not None:
3064 chandransh 2282 
      raise result.ex
2283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2284 
 
3064 chandransh 2285 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2286 
    """
3064 chandransh 2287 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2288 
    the name of the receiver.
2289 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2290 
 
304 ashish 2291 
    Parameters:
3064 chandransh 2292 
     - providerId
2293 
     - deliveredOrders
304 ashish 2294 
    """
3064 chandransh 2295 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2296 
    self.recv_markOrdersAsDelivered()
304 ashish 2297 
 
3064 chandransh 2298 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2299 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2300 
    args = markOrdersAsDelivered_args()
2301 
    args.providerId = providerId
2302 
    args.deliveredOrders = deliveredOrders
304 ashish 2303 
    args.write(self._oprot)
2304 
    self._oprot.writeMessageEnd()
2305 
    self._oprot.trans.flush()
2306 
 
3064 chandransh 2307 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2309 
    if mtype == TMessageType.EXCEPTION:
2310 
      x = TApplicationException()
2311 
      x.read(self._iprot)
2312 
      self._iprot.readMessageEnd()
2313 
      raise x
3064 chandransh 2314 
    result = markOrdersAsDelivered_result()
304 ashish 2315 
    result.read(self._iprot)
2316 
    self._iprot.readMessageEnd()
3431 rajveer 2317 
    if result.ex is not None:
3064 chandransh 2318 
      raise result.ex
304 ashish 2319 
    return
2320 
 
3064 chandransh 2321 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2322 
    """
3064 chandransh 2323 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2324 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2325 
 
3064 chandransh 2326 
    Parameters:
2327 
     - providerId
2328 
     - returnedOrders
1596 ankur.sing 2329 
    """
3064 chandransh 2330 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2331 
    self.recv_markOrdersAsFailed()
304 ashish 2332 
 
3064 chandransh 2333 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2334 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2335 
    args = markOrdersAsFailed_args()
2336 
    args.providerId = providerId
2337 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
3064 chandransh 2342 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
3064 chandransh 2349 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
3431 rajveer 2352 
    if result.ex is not None:
3064 chandransh 2353 
      raise result.ex
2354 
    return
1596 ankur.sing 2355 
 
3064 chandransh 2356 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2357 
    """
3064 chandransh 2358 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2359 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2360 
 
3064 chandransh 2361 
    Parameters:
2362 
     - providerId
2363 
     - undeliveredOrders
1627 ankur.sing 2364 
    """
3064 chandransh 2365 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2366 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2367 
 
3064 chandransh 2368 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2369 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2370 
    args = updateNonDeliveryReason_args()
2371 
    args.providerId = providerId
2372 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
3064 chandransh 2377 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
3064 chandransh 2384 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
4581 phani.kuma 2387 
    if result.success is not None:
2388 
      return result.success
3431 rajveer 2389 
    if result.ex is not None:
3064 chandransh 2390 
      raise result.ex
4581 phani.kuma 2391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2392 
 
3064 chandransh 2393 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2394 
    """
3064 chandransh 2395 
    Returns the list of orders whose delivery time has passed but have not been
2396 
    delivered yet for the given provider and warehouse. To get a complete list of
2397 
    undelivered orders, pass them as -1.
2398 
    Returns an empty list if no such orders exist.
3431 rajveer 2399 
 
1886 ankur.sing 2400 
    Parameters:
3064 chandransh 2401 
     - providerId
2402 
     - warehouseId
1886 ankur.sing 2403 
    """
3064 chandransh 2404 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2405 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2406 
 
3064 chandransh 2407 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2408 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2409 
    args = getUndeliveredOrders_args()
2410 
    args.providerId = providerId
2411 
    args.warehouseId = warehouseId
1886 ankur.sing 2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
3064 chandransh 2416 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
3064 chandransh 2423 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
3431 rajveer 2426 
    if result.success is not None:
1886 ankur.sing 2427 
      return result.success
3064 chandransh 2428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2429 
 
2536 chandransh 2430 
  def toggleDOAFlag(self, orderId):
2431 
    """
2432 
    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.
2433 
    Returns the final flag status.
2434 
    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 2435 
 
2536 chandransh 2436 
    Parameters:
2437 
     - orderId
2438 
    """
2439 
    self.send_toggleDOAFlag(orderId)
2440 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2441 
 
2536 chandransh 2442 
  def send_toggleDOAFlag(self, orderId):
2443 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2444 
    args = toggleDOAFlag_args()
2445 
    args.orderId = orderId
2446 
    args.write(self._oprot)
2447 
    self._oprot.writeMessageEnd()
2448 
    self._oprot.trans.flush()
2449 
 
2450 
  def recv_toggleDOAFlag(self, ):
2451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2452 
    if mtype == TMessageType.EXCEPTION:
2453 
      x = TApplicationException()
2454 
      x.read(self._iprot)
2455 
      self._iprot.readMessageEnd()
2456 
      raise x
2457 
    result = toggleDOAFlag_result()
2458 
    result.read(self._iprot)
2459 
    self._iprot.readMessageEnd()
3431 rajveer 2460 
    if result.success is not None:
2536 chandransh 2461 
      return result.success
3431 rajveer 2462 
    if result.ex is not None:
2536 chandransh 2463 
      raise result.ex
2464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2465 
 
4454 rajveer 2466 
  def markOrderDoaRequestReceived(self, orderId):
2467 
    """
2468 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2469 
 
2470 
    Parameters:
2471 
     - orderId
2472 
    """
2473 
    self.send_markOrderDoaRequestReceived(orderId)
2474 
    return self.recv_markOrderDoaRequestReceived()
2475 
 
2476 
  def send_markOrderDoaRequestReceived(self, orderId):
2477 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2478 
    args = markOrderDoaRequestReceived_args()
2479 
    args.orderId = orderId
2480 
    args.write(self._oprot)
2481 
    self._oprot.writeMessageEnd()
2482 
    self._oprot.trans.flush()
2483 
 
2484 
  def recv_markOrderDoaRequestReceived(self, ):
2485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2486 
    if mtype == TMessageType.EXCEPTION:
2487 
      x = TApplicationException()
2488 
      x.read(self._iprot)
2489 
      self._iprot.readMessageEnd()
2490 
      raise x
2491 
    result = markOrderDoaRequestReceived_result()
2492 
    result.read(self._iprot)
2493 
    self._iprot.readMessageEnd()
2494 
    if result.success is not None:
2495 
      return result.success
2496 
    if result.ex is not None:
2497 
      raise result.ex
2498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2499 
 
2500 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2501 
    """
2502 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2503 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2504 
 
2505 
    Parameters:
2506 
     - orderId
2507 
     - isAuthorized
2508 
    """
2509 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2510 
    return self.recv_markOrderDoaRequestAuthorized()
2511 
 
2512 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2513 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2514 
    args = markOrderDoaRequestAuthorized_args()
2515 
    args.orderId = orderId
2516 
    args.isAuthorized = isAuthorized
2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
2521 
  def recv_markOrderDoaRequestAuthorized(self, ):
2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
2528 
    result = markOrderDoaRequestAuthorized_result()
2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
2531 
    if result.success is not None:
2532 
      return result.success
2533 
    if result.ex is not None:
2534 
      raise result.ex
2535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2536 
 
4488 rajveer 2537 
  def markOrderReturnRequestReceived(self, orderId):
2538 
    """
2539 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2540 
 
2541 
    Parameters:
2542 
     - orderId
2543 
    """
2544 
    self.send_markOrderReturnRequestReceived(orderId)
2545 
    return self.recv_markOrderReturnRequestReceived()
2546 
 
2547 
  def send_markOrderReturnRequestReceived(self, orderId):
2548 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2549 
    args = markOrderReturnRequestReceived_args()
2550 
    args.orderId = orderId
2551 
    args.write(self._oprot)
2552 
    self._oprot.writeMessageEnd()
2553 
    self._oprot.trans.flush()
2554 
 
2555 
  def recv_markOrderReturnRequestReceived(self, ):
2556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2557 
    if mtype == TMessageType.EXCEPTION:
2558 
      x = TApplicationException()
2559 
      x.read(self._iprot)
2560 
      self._iprot.readMessageEnd()
2561 
      raise x
2562 
    result = markOrderReturnRequestReceived_result()
2563 
    result.read(self._iprot)
2564 
    self._iprot.readMessageEnd()
2565 
    if result.success is not None:
2566 
      return result.success
2567 
    if result.ex is not None:
2568 
      raise result.ex
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2570 
 
2571 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2572 
    """
2573 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2574 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2575 
 
2576 
    Parameters:
2577 
     - orderId
2578 
     - isAuthorized
2579 
    """
2580 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2581 
    return self.recv_markOrderReturnRequestAuthorized()
2582 
 
2583 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2584 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2585 
    args = markOrderReturnRequestAuthorized_args()
2586 
    args.orderId = orderId
2587 
    args.isAuthorized = isAuthorized
2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
2592 
  def recv_markOrderReturnRequestAuthorized(self, ):
2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
2599 
    result = markOrderReturnRequestAuthorized_result()
2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
2602 
    if result.success is not None:
2603 
      return result.success
2604 
    if result.ex is not None:
2605 
      raise result.ex
2606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2607 
 
4579 rajveer 2608 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2609 
    """
2610 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2611 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2612 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2613 
    For any other status, it returns false.
2614 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2615 
 
2536 chandransh 2616 
    Parameters:
2617 
     - orderId
4579 rajveer 2618 
     - providerId
2536 chandransh 2619 
    """
4579 rajveer 2620 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2621 
    return self.recv_requestPickupNumber()
2622 
 
4579 rajveer 2623 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2624 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2625 
    args = requestPickupNumber_args()
2626 
    args.orderId = orderId
4579 rajveer 2627 
    args.providerId = providerId
2536 chandransh 2628 
    args.write(self._oprot)
2629 
    self._oprot.writeMessageEnd()
2630 
    self._oprot.trans.flush()
2631 
 
2632 
  def recv_requestPickupNumber(self, ):
2633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2634 
    if mtype == TMessageType.EXCEPTION:
2635 
      x = TApplicationException()
2636 
      x.read(self._iprot)
2637 
      self._iprot.readMessageEnd()
2638 
      raise x
2639 
    result = requestPickupNumber_result()
2640 
    result.read(self._iprot)
2641 
    self._iprot.readMessageEnd()
3431 rajveer 2642 
    if result.success is not None:
2536 chandransh 2643 
      return result.success
3431 rajveer 2644 
    if result.ex is not None:
2536 chandransh 2645 
      raise result.ex
2646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2647 
 
4602 rajveer 2648 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2649 
    """
4452 rajveer 2650 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2651 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2652 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2653 
    	3. Returns true
2591 chandransh 2654 
    If the order is in any other status, it returns false.
2536 chandransh 2655 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2656 
 
2536 chandransh 2657 
    Parameters:
2658 
     - orderId
2659 
     - pickupNumber
4602 rajveer 2660 
     - providerId
2536 chandransh 2661 
    """
4602 rajveer 2662 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2663 
    return self.recv_authorizePickup()
2664 
 
4602 rajveer 2665 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2666 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2667 
    args = authorizePickup_args()
2668 
    args.orderId = orderId
2669 
    args.pickupNumber = pickupNumber
4602 rajveer 2670 
    args.providerId = providerId
2536 chandransh 2671 
    args.write(self._oprot)
2672 
    self._oprot.writeMessageEnd()
2673 
    self._oprot.trans.flush()
2674 
 
2675 
  def recv_authorizePickup(self, ):
2676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2677 
    if mtype == TMessageType.EXCEPTION:
2678 
      x = TApplicationException()
2679 
      x.read(self._iprot)
2680 
      self._iprot.readMessageEnd()
2681 
      raise x
2682 
    result = authorizePickup_result()
2683 
    result.read(self._iprot)
2684 
    self._iprot.readMessageEnd()
3431 rajveer 2685 
    if result.success is not None:
2536 chandransh 2686 
      return result.success
3431 rajveer 2687 
    if result.ex is not None:
2536 chandransh 2688 
      raise result.ex
2689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2690 
 
2764 chandransh 2691 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2692 
    """
2693 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2694 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2695 
 
2764 chandransh 2696 
    Parameters:
2697 
     - providerId
2698 
     - pickupDetails
2699 
    """
2700 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2701 
    return self.recv_markDoasAsPickedUp()
2702 
 
2703 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2704 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2705 
    args = markDoasAsPickedUp_args()
2706 
    args.providerId = providerId
2707 
    args.pickupDetails = pickupDetails
2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_markDoasAsPickedUp(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = markDoasAsPickedUp_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
3431 rajveer 2722 
    if result.success is not None:
2764 chandransh 2723 
      return result.success
2724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2725 
 
4479 rajveer 2726 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2727 
    """
4452 rajveer 2728 
    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 2729 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2730 
    If the order is in any other state, it returns false.
2731 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2732 
 
2591 chandransh 2733 
    Parameters:
2734 
     - orderId
4479 rajveer 2735 
     - receiveCondition
2591 chandransh 2736 
    """
4479 rajveer 2737 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2738 
    return self.recv_receiveReturn()
2536 chandransh 2739 
 
4479 rajveer 2740 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2741 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2742 
    args = receiveReturn_args()
2591 chandransh 2743 
    args.orderId = orderId
4479 rajveer 2744 
    args.receiveCondition = receiveCondition
2591 chandransh 2745 
    args.write(self._oprot)
2746 
    self._oprot.writeMessageEnd()
2747 
    self._oprot.trans.flush()
2748 
 
2616 chandransh 2749 
  def recv_receiveReturn(self, ):
2591 chandransh 2750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2751 
    if mtype == TMessageType.EXCEPTION:
2752 
      x = TApplicationException()
2753 
      x.read(self._iprot)
2754 
      self._iprot.readMessageEnd()
2755 
      raise x
2616 chandransh 2756 
    result = receiveReturn_result()
2591 chandransh 2757 
    result.read(self._iprot)
2758 
    self._iprot.readMessageEnd()
3431 rajveer 2759 
    if result.success is not None:
2591 chandransh 2760 
      return result.success
3431 rajveer 2761 
    if result.ex is not None:
2591 chandransh 2762 
      raise result.ex
2616 chandransh 2763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2764 
 
2765 
  def validateDoa(self, orderId, isValid):
2766 
    """
4452 rajveer 2767 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2768 
    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 2769 
    If the order is in any other state, it returns false.
2770 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2771 
 
2591 chandransh 2772 
    Parameters:
2773 
     - orderId
2774 
     - isValid
2775 
    """
2776 
    self.send_validateDoa(orderId, isValid)
2777 
    return self.recv_validateDoa()
2778 
 
2779 
  def send_validateDoa(self, orderId, isValid):
2780 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2781 
    args = validateDoa_args()
2782 
    args.orderId = orderId
2783 
    args.isValid = isValid
2784 
    args.write(self._oprot)
2785 
    self._oprot.writeMessageEnd()
2786 
    self._oprot.trans.flush()
2787 
 
2788 
  def recv_validateDoa(self, ):
2789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2790 
    if mtype == TMessageType.EXCEPTION:
2791 
      x = TApplicationException()
2792 
      x.read(self._iprot)
2793 
      self._iprot.readMessageEnd()
2794 
      raise x
2795 
    result = validateDoa_result()
2796 
    result.read(self._iprot)
2797 
    self._iprot.readMessageEnd()
3431 rajveer 2798 
    if result.success is not None:
2591 chandransh 2799 
      return result.success
3431 rajveer 2800 
    if result.ex is not None:
2591 chandransh 2801 
      raise result.ex
2802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2803 
 
4495 rajveer 2804 
  def validateReturnProduct(self, orderId, isUsable):
2805 
    """
2806 
    Parameters:
2807 
     - orderId
2808 
     - isUsable
2809 
    """
2810 
    self.send_validateReturnProduct(orderId, isUsable)
2811 
    return self.recv_validateReturnProduct()
2812 
 
2813 
  def send_validateReturnProduct(self, orderId, isUsable):
2814 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2815 
    args = validateReturnProduct_args()
2816 
    args.orderId = orderId
2817 
    args.isUsable = isUsable
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_validateReturnProduct(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = validateReturnProduct_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    if result.ex is not None:
2835 
      raise result.ex
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2837 
 
2616 chandransh 2838 
  def reshipOrder(self, orderId):
2839 
    """
4484 rajveer 2840 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2841 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2842 
    	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 2843 
 
2844 
    If the order is in DOA_CERT_VALID state, it does the following:
2845 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2846 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2847 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2848 
 
2616 chandransh 2849 
    Returns the id of the newly created order.
3431 rajveer 2850 
 
2616 chandransh 2851 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2852 
 
2616 chandransh 2853 
    Parameters:
2854 
     - orderId
2855 
    """
2856 
    self.send_reshipOrder(orderId)
2857 
    return self.recv_reshipOrder()
2591 chandransh 2858 
 
2616 chandransh 2859 
  def send_reshipOrder(self, orderId):
2860 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2861 
    args = reshipOrder_args()
2862 
    args.orderId = orderId
2863 
    args.write(self._oprot)
2864 
    self._oprot.writeMessageEnd()
2865 
    self._oprot.trans.flush()
2866 
 
2867 
  def recv_reshipOrder(self, ):
2868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2869 
    if mtype == TMessageType.EXCEPTION:
2870 
      x = TApplicationException()
2871 
      x.read(self._iprot)
2872 
      self._iprot.readMessageEnd()
2873 
      raise x
2874 
    result = reshipOrder_result()
2875 
    result.read(self._iprot)
2876 
    self._iprot.readMessageEnd()
3431 rajveer 2877 
    if result.success is not None:
2616 chandransh 2878 
      return result.success
3431 rajveer 2879 
    if result.ex is not None:
2616 chandransh 2880 
      raise result.ex
2881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2882 
 
3226 chandransh 2883 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2884 
    """
4484 rajveer 2885 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2886 
    	1. Creates a refund request for batch processing.
2887 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2888 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2889 
 
2616 chandransh 2890 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2891 
    	1. Creates a refund request for batch processing.
3226 chandransh 2892 
    	2. Cancels the reservation of the item in the warehouse.
2893 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2894 
 
3226 chandransh 2895 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2896 
    	1. Cancels the reservation of the item in the warehouse.
2897 
    	2. Marks the current order as CANCELED.
2898 
 
2899 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2900 
 
2616 chandransh 2901 
    Returns True if it is successful, False otherwise.
3431 rajveer 2902 
 
2616 chandransh 2903 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2904 
 
2616 chandransh 2905 
    Parameters:
2906 
     - orderId
3226 chandransh 2907 
     - refundedBy
2908 
     - reason
2616 chandransh 2909 
    """
3226 chandransh 2910 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2911 
    return self.recv_refundOrder()
2912 
 
3226 chandransh 2913 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2914 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2915 
    args = refundOrder_args()
2916 
    args.orderId = orderId
3226 chandransh 2917 
    args.refundedBy = refundedBy
2918 
    args.reason = reason
2616 chandransh 2919 
    args.write(self._oprot)
2920 
    self._oprot.writeMessageEnd()
2921 
    self._oprot.trans.flush()
2922 
 
2923 
  def recv_refundOrder(self, ):
2924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2925 
    if mtype == TMessageType.EXCEPTION:
2926 
      x = TApplicationException()
2927 
      x.read(self._iprot)
2928 
      self._iprot.readMessageEnd()
2929 
      raise x
2930 
    result = refundOrder_result()
2931 
    result.read(self._iprot)
2932 
    self._iprot.readMessageEnd()
3431 rajveer 2933 
    if result.success is not None:
2616 chandransh 2934 
      return result.success
3431 rajveer 2935 
    if result.ex is not None:
2616 chandransh 2936 
      raise result.ex
2937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2938 
 
2690 chandransh 2939 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2940 
    """
2941 
    Get all return orders created between the from and to dates for the given warehouse.
2942 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2943 
 
2690 chandransh 2944 
    Parameters:
2945 
     - warehouseId
2946 
     - fromDate
2947 
     - toDate
2948 
    """
2949 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2950 
    return self.recv_getReturnOrders()
2616 chandransh 2951 
 
2690 chandransh 2952 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2953 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2954 
    args = getReturnOrders_args()
2955 
    args.warehouseId = warehouseId
2956 
    args.fromDate = fromDate
2957 
    args.toDate = toDate
2958 
    args.write(self._oprot)
2959 
    self._oprot.writeMessageEnd()
2960 
    self._oprot.trans.flush()
2961 
 
2962 
  def recv_getReturnOrders(self, ):
2963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2964 
    if mtype == TMessageType.EXCEPTION:
2965 
      x = TApplicationException()
2966 
      x.read(self._iprot)
2967 
      self._iprot.readMessageEnd()
2968 
      raise x
2969 
    result = getReturnOrders_result()
2970 
    result.read(self._iprot)
2971 
    self._iprot.readMessageEnd()
3431 rajveer 2972 
    if result.success is not None:
2690 chandransh 2973 
      return result.success
2974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2975 
 
2700 chandransh 2976 
  def getReturnOrder(self, id):
2977 
    """
2978 
    Returns the ReturnOrder corresponding to the given id.
2979 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2980 
 
2700 chandransh 2981 
    Parameters:
2982 
     - id
2983 
    """
2984 
    self.send_getReturnOrder(id)
2985 
    return self.recv_getReturnOrder()
2986 
 
2987 
  def send_getReturnOrder(self, id):
2988 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2989 
    args = getReturnOrder_args()
2990 
    args.id = id
2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
2995 
  def recv_getReturnOrder(self, ):
2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
3002 
    result = getReturnOrder_result()
3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3431 rajveer 3005 
    if result.success is not None:
2700 chandransh 3006 
      return result.success
3431 rajveer 3007 
    if result.ex is not None:
2700 chandransh 3008 
      raise result.ex
3009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3010 
 
2690 chandransh 3011 
  def processReturn(self, returnOrderId):
3012 
    """
3013 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3014 
 
2690 chandransh 3015 
    Parameters:
3016 
     - returnOrderId
3017 
    """
3018 
    self.send_processReturn(returnOrderId)
3019 
    self.recv_processReturn()
3020 
 
3021 
  def send_processReturn(self, returnOrderId):
3022 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3023 
    args = processReturn_args()
3024 
    args.returnOrderId = returnOrderId
3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
3029 
  def recv_processReturn(self, ):
3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
3036 
    result = processReturn_result()
3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3431 rajveer 3039 
    if result.ex is not None:
2690 chandransh 3040 
      raise result.ex
3041 
    return
3042 
 
2819 chandransh 3043 
  def createPurchaseOrder(self, warehouseId):
3044 
    """
4586 mandeep.dh 3045 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3046 
    Returns the list of PO no. of the newly created purchase order.
3047 
    Returns null if no new purchase order had to be created.
3431 rajveer 3048 
 
2819 chandransh 3049 
    Parameters:
3050 
     - warehouseId
3051 
    """
3052 
    self.send_createPurchaseOrder(warehouseId)
3053 
    return self.recv_createPurchaseOrder()
2690 chandransh 3054 
 
2819 chandransh 3055 
  def send_createPurchaseOrder(self, warehouseId):
3056 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3057 
    args = createPurchaseOrder_args()
3058 
    args.warehouseId = warehouseId
3059 
    args.write(self._oprot)
3060 
    self._oprot.writeMessageEnd()
3061 
    self._oprot.trans.flush()
3062 
 
3063 
  def recv_createPurchaseOrder(self, ):
3064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3065 
    if mtype == TMessageType.EXCEPTION:
3066 
      x = TApplicationException()
3067 
      x.read(self._iprot)
3068 
      self._iprot.readMessageEnd()
3069 
      raise x
3070 
    result = createPurchaseOrder_result()
3071 
    result.read(self._iprot)
3072 
    self._iprot.readMessageEnd()
3431 rajveer 3073 
    if result.success is not None:
2819 chandransh 3074 
      return result.success
3431 rajveer 3075 
    if result.ex is not None:
2819 chandransh 3076 
      raise result.ex
3077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3078 
 
3451 chandransh 3079 
  def updateWeight(self, orderId, weight):
3080 
    """
3081 
    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 3082 
 
3451 chandransh 3083 
    Parameters:
3084 
     - orderId
3085 
     - weight
3086 
    """
3087 
    self.send_updateWeight(orderId, weight)
3088 
    return self.recv_updateWeight()
3089 
 
3090 
  def send_updateWeight(self, orderId, weight):
3091 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3092 
    args = updateWeight_args()
3093 
    args.orderId = orderId
3094 
    args.weight = weight
3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3099 
  def recv_updateWeight(self, ):
3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3106 
    result = updateWeight_result()
3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
3109 
    if result.success is not None:
3110 
      return result.success
3111 
    if result.ex is not None:
3112 
      raise result.ex
3113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3114 
 
3469 chandransh 3115 
  def changeItem(self, orderId, itemId):
3116 
    """
3117 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3118 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3119 
 
3469 chandransh 3120 
    Parameters:
3121 
     - orderId
3122 
     - itemId
3123 
    """
3124 
    self.send_changeItem(orderId, itemId)
3125 
    return self.recv_changeItem()
3126 
 
3127 
  def send_changeItem(self, orderId, itemId):
3128 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3129 
    args = changeItem_args()
3130 
    args.orderId = orderId
3131 
    args.itemId = itemId
3132 
    args.write(self._oprot)
3133 
    self._oprot.writeMessageEnd()
3134 
    self._oprot.trans.flush()
3135 
 
3136 
  def recv_changeItem(self, ):
3137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3138 
    if mtype == TMessageType.EXCEPTION:
3139 
      x = TApplicationException()
3140 
      x.read(self._iprot)
3141 
      self._iprot.readMessageEnd()
3142 
      raise x
3143 
    result = changeItem_result()
3144 
    result.read(self._iprot)
3145 
    self._iprot.readMessageEnd()
3146 
    if result.success is not None:
3147 
      return result.success
3148 
    if result.ex is not None:
3149 
      raise result.ex
3150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3151 
 
3152 
  def shiftToWarehouse(self, orderId, warehouseId):
3153 
    """
3154 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3155 
 
3156 
    Parameters:
3157 
     - orderId
3158 
     - warehouseId
3159 
    """
3160 
    self.send_shiftToWarehouse(orderId, warehouseId)
3161 
    return self.recv_shiftToWarehouse()
3162 
 
3163 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3164 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3165 
    args = shiftToWarehouse_args()
3166 
    args.orderId = orderId
3167 
    args.warehouseId = warehouseId
3168 
    args.write(self._oprot)
3169 
    self._oprot.writeMessageEnd()
3170 
    self._oprot.trans.flush()
3171 
 
3172 
  def recv_shiftToWarehouse(self, ):
3173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3174 
    if mtype == TMessageType.EXCEPTION:
3175 
      x = TApplicationException()
3176 
      x.read(self._iprot)
3177 
      self._iprot.readMessageEnd()
3178 
      raise x
3179 
    result = shiftToWarehouse_result()
3180 
    result.read(self._iprot)
3181 
    self._iprot.readMessageEnd()
3182 
    if result.success is not None:
3183 
      return result.success
3184 
    if result.ex is not None:
3185 
      raise result.ex
3186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3187 
 
4647 rajveer 3188 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3189 
    """
3190 
    Adds the given delay reason to the given order.
3986 chandransh 3191 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3192 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3193 
 
3553 chandransh 3194 
    Parameters:
3195 
     - orderId
3196 
     - delayReason
3986 chandransh 3197 
     - furtherDelay
4647 rajveer 3198 
     - delayReasonText
3553 chandransh 3199 
    """
4647 rajveer 3200 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3201 
    return self.recv_addDelayReason()
3202 
 
4647 rajveer 3203 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3204 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3205 
    args = addDelayReason_args()
3206 
    args.orderId = orderId
3207 
    args.delayReason = delayReason
3986 chandransh 3208 
    args.furtherDelay = furtherDelay
4647 rajveer 3209 
    args.delayReasonText = delayReasonText
3553 chandransh 3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_addDelayReason(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = addDelayReason_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.success is not None:
3225 
      return result.success
3226 
    if result.ex is not None:
3227 
      raise result.ex
3228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3229 
 
3956 chandransh 3230 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3231 
    """
3232 
    Marks the COD orders with given AWB nos. as having been processed.
3233 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3234 
 
3956 chandransh 3235 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3236 
    1. There is no order corresponding to an AWB number.
3237 
    2. The captured amount for a payment exceeds the total payment.
3238 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3239 
 
3240 
    Parameters:
3241 
     - collectedAmountMap
3242 
     - xferBy
3243 
     - xferTxnId
3244 
     - xferDate
3245 
    """
3246 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3247 
    return self.recv_reconcileCodCollection()
3248 
 
3249 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3250 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3251 
    args = reconcileCodCollection_args()
3252 
    args.collectedAmountMap = collectedAmountMap
3253 
    args.xferBy = xferBy
3254 
    args.xferTxnId = xferTxnId
3255 
    args.xferDate = xferDate
3256 
    args.write(self._oprot)
3257 
    self._oprot.writeMessageEnd()
3258 
    self._oprot.trans.flush()
3259 
 
3260 
  def recv_reconcileCodCollection(self, ):
3261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3262 
    if mtype == TMessageType.EXCEPTION:
3263 
      x = TApplicationException()
3264 
      x.read(self._iprot)
3265 
      self._iprot.readMessageEnd()
3266 
      raise x
3267 
    result = reconcileCodCollection_result()
3268 
    result.read(self._iprot)
3269 
    self._iprot.readMessageEnd()
3270 
    if result.success is not None:
3271 
      return result.success
3272 
    if result.ex is not None:
3273 
      raise result.ex
3274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3275 
 
4008 mandeep.dh 3276 
  def getTransactionsRequiringExtraProcessing(self, category):
3277 
    """
4065 mandeep.dh 3278 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3279 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3280 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3281 
 
4008 mandeep.dh 3282 
    Parameters:
3283 
     - category
3284 
    """
3285 
    self.send_getTransactionsRequiringExtraProcessing(category)
3286 
    return self.recv_getTransactionsRequiringExtraProcessing()
3287 
 
3288 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3289 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3290 
    args = getTransactionsRequiringExtraProcessing_args()
3291 
    args.category = category
3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = getTransactionsRequiringExtraProcessing_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3309 
 
3310 
  def markTransactionAsProcessed(self, transactionId, category):
3311 
    """
3312 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3313 
    It essentially deletes the transaction id record for a particular
3314 
    processing type category (if present) from DB.
3315 
    This is currently used by CRM application.
4008 mandeep.dh 3316 
 
3317 
    Parameters:
3318 
     - transactionId
3319 
     - category
3320 
    """
3321 
    self.send_markTransactionAsProcessed(transactionId, category)
3322 
    self.recv_markTransactionAsProcessed()
3323 
 
3324 
  def send_markTransactionAsProcessed(self, transactionId, category):
3325 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3326 
    args = markTransactionAsProcessed_args()
3327 
    args.transactionId = transactionId
3328 
    args.category = category
3329 
    args.write(self._oprot)
3330 
    self._oprot.writeMessageEnd()
3331 
    self._oprot.trans.flush()
3332 
 
3333 
  def recv_markTransactionAsProcessed(self, ):
3334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3335 
    if mtype == TMessageType.EXCEPTION:
3336 
      x = TApplicationException()
3337 
      x.read(self._iprot)
3338 
      self._iprot.readMessageEnd()
3339 
      raise x
3340 
    result = markTransactionAsProcessed_result()
3341 
    result.read(self._iprot)
3342 
    self._iprot.readMessageEnd()
3343 
    return
3344 
 
4018 chandransh 3345 
  def getItemWiseRiskyOrdersCount(self, ):
3346 
    """
3347 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3348 
    is defined as one whose shipping date is about to expire.
3349 
    """
3350 
    self.send_getItemWiseRiskyOrdersCount()
3351 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3352 
 
4018 chandransh 3353 
  def send_getItemWiseRiskyOrdersCount(self, ):
3354 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3355 
    args = getItemWiseRiskyOrdersCount_args()
3356 
    args.write(self._oprot)
3357 
    self._oprot.writeMessageEnd()
3358 
    self._oprot.trans.flush()
3359 
 
3360 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3362 
    if mtype == TMessageType.EXCEPTION:
3363 
      x = TApplicationException()
3364 
      x.read(self._iprot)
3365 
      self._iprot.readMessageEnd()
3366 
      raise x
3367 
    result = getItemWiseRiskyOrdersCount_result()
3368 
    result.read(self._iprot)
3369 
    self._iprot.readMessageEnd()
3370 
    if result.success is not None:
3371 
      return result.success
3372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3373 
 
4295 varun.gupt 3374 
  def getOrdersForItemIds(self, itemIds):
3375 
    """
3376 
    Returns a list of all orders which have items with given id
3377 
 
3378 
    Parameters:
3379 
     - itemIds
3380 
    """
3381 
    self.send_getOrdersForItemIds(itemIds)
3382 
    return self.recv_getOrdersForItemIds()
3383 
 
3384 
  def send_getOrdersForItemIds(self, itemIds):
3385 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3386 
    args = getOrdersForItemIds_args()
3387 
    args.itemIds = itemIds
3388 
    args.write(self._oprot)
3389 
    self._oprot.writeMessageEnd()
3390 
    self._oprot.trans.flush()
3391 
 
3392 
  def recv_getOrdersForItemIds(self, ):
3393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3394 
    if mtype == TMessageType.EXCEPTION:
3395 
      x = TApplicationException()
3396 
      x.read(self._iprot)
3397 
      self._iprot.readMessageEnd()
3398 
      raise x
3399 
    result = getOrdersForItemIds_result()
3400 
    result.read(self._iprot)
3401 
    self._iprot.readMessageEnd()
3402 
    if result.success is not None:
3403 
      return result.success
3404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3405 
 
4247 rajveer 3406 
  def markOrderCancellationRequestReceived(self, orderId):
3407 
    """
3408 
    Mark order as cancellation request received. If customer sends request of cancellation of
3409 
    a particular order, this method will be called. It will just change status of the order
3410 
    depending on its current status. It also records the previous status, so that we can move
3411 
    back to that status if cancellation request is denied.
4018 chandransh 3412 
 
4247 rajveer 3413 
    Parameters:
3414 
     - orderId
3415 
    """
3416 
    self.send_markOrderCancellationRequestReceived(orderId)
3417 
    self.recv_markOrderCancellationRequestReceived()
3418 
 
3419 
  def send_markOrderCancellationRequestReceived(self, orderId):
3420 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3421 
    args = markOrderCancellationRequestReceived_args()
3422 
    args.orderId = orderId
3423 
    args.write(self._oprot)
3424 
    self._oprot.writeMessageEnd()
3425 
    self._oprot.trans.flush()
3426 
 
3427 
  def recv_markOrderCancellationRequestReceived(self, ):
3428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3429 
    if mtype == TMessageType.EXCEPTION:
3430 
      x = TApplicationException()
3431 
      x.read(self._iprot)
3432 
      self._iprot.readMessageEnd()
3433 
      raise x
3434 
    result = markOrderCancellationRequestReceived_result()
3435 
    result.read(self._iprot)
3436 
    self._iprot.readMessageEnd()
3437 
    if result.ex is not None:
3438 
      raise result.ex
3439 
    return
3440 
 
3441 
  def markOrderCancellationRequestConfirmed(self, orderId):
3442 
    """
3443 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3444 
    cancellation request confirmed. After this OM will be able to cancel the order.
3445 
 
3446 
    Parameters:
3447 
     - orderId
3448 
    """
3449 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3450 
    self.recv_markOrderCancellationRequestConfirmed()
3451 
 
3452 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3453 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3454 
    args = markOrderCancellationRequestConfirmed_args()
3455 
    args.orderId = orderId
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = markOrderCancellationRequestConfirmed_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    if result.ex is not None:
3471 
      raise result.ex
3472 
    return
3473 
 
3474 
  def markOrderCancellationRequestDenied(self, orderId):
3475 
    """
3476 
    If we decide to not to cancel order, we will move the order ro previous status.
3477 
 
3478 
    Parameters:
3479 
     - orderId
3480 
    """
3481 
    self.send_markOrderCancellationRequestDenied(orderId)
3482 
    self.recv_markOrderCancellationRequestDenied()
3483 
 
3484 
  def send_markOrderCancellationRequestDenied(self, orderId):
3485 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3486 
    args = markOrderCancellationRequestDenied_args()
3487 
    args.orderId = orderId
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_markOrderCancellationRequestDenied(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = markOrderCancellationRequestDenied_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    if result.ex is not None:
3503 
      raise result.ex
3504 
    return
3505 
 
4258 rajveer 3506 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3507 
    """
4258 rajveer 3508 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3509 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3510 
 
3511 
    Parameters:
4258 rajveer 3512 
     - transactionId
4247 rajveer 3513 
    """
4258 rajveer 3514 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3515 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3516 
 
4258 rajveer 3517 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3518 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3519 
    args = markTransactionAsPaymentFlagRemoved_args()
3520 
    args.transactionId = transactionId
4247 rajveer 3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
4258 rajveer 3525 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
4258 rajveer 3532 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.ex is not None:
3536 
      raise result.ex
3537 
    return
3538 
 
4259 anupam.sin 3539 
  def refundTransaction(self, transactionId, refundedBy, reason):
3540 
    """
3541 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3542 
    need to be cancelled
4247 rajveer 3543 
 
4259 anupam.sin 3544 
    Parameters:
3545 
     - transactionId
3546 
     - refundedBy
3547 
     - reason
3548 
    """
3549 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3550 
    self.recv_refundTransaction()
3551 
 
3552 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3553 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3554 
    args = refundTransaction_args()
3555 
    args.transactionId = transactionId
3556 
    args.refundedBy = refundedBy
3557 
    args.reason = reason
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_refundTransaction(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = refundTransaction_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
3572 
    if result.ex is not None:
3573 
      raise result.ex
3574 
    return
3575 
 
4324 mandeep.dh 3576 
  def updateShipmentAddress(self, orderId, addressId):
3577 
    """
3578 
    Updates shipment address of an order. Delivery and shipping date estimates
3579 
    etc. are also updated here.
3580 
 
3581 
    Throws TransactionServiceException in case address change is not
3582 
    possible due to certain reasons such as new pincode in address is
3583 
    not serviceable etc.
3584 
 
3585 
    Parameters:
3586 
     - orderId
3587 
     - addressId
3588 
    """
3589 
    self.send_updateShipmentAddress(orderId, addressId)
3590 
    self.recv_updateShipmentAddress()
3591 
 
3592 
  def send_updateShipmentAddress(self, orderId, addressId):
3593 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3594 
    args = updateShipmentAddress_args()
3595 
    args.orderId = orderId
3596 
    args.addressId = addressId
3597 
    args.write(self._oprot)
3598 
    self._oprot.writeMessageEnd()
3599 
    self._oprot.trans.flush()
3600 
 
3601 
  def recv_updateShipmentAddress(self, ):
3602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3603 
    if mtype == TMessageType.EXCEPTION:
3604 
      x = TApplicationException()
3605 
      x.read(self._iprot)
3606 
      self._iprot.readMessageEnd()
3607 
      raise x
3608 
    result = updateShipmentAddress_result()
3609 
    result.read(self._iprot)
3610 
    self._iprot.readMessageEnd()
3611 
    if result.ex is not None:
3612 
      raise result.ex
3613 
    return
3614 
 
4285 rajveer 3615 
  def acceptOrdersForItemId(self, itemId, inventory):
3616 
    """
3617 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3618 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3619 
 
4285 rajveer 3620 
    Parameters:
3621 
     - itemId
3622 
     - inventory
3623 
    """
3624 
    self.send_acceptOrdersForItemId(itemId, inventory)
3625 
    return self.recv_acceptOrdersForItemId()
3626 
 
3627 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3628 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3629 
    args = acceptOrdersForItemId_args()
3630 
    args.itemId = itemId
3631 
    args.inventory = inventory
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_acceptOrdersForItemId(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = acceptOrdersForItemId_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    if result.success is not None:
3647 
      return result.success
3648 
    if result.ex is not None:
3649 
      raise result.ex
3650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3651 
 
4369 rajveer 3652 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3653 
    """
3654 
    Parameters:
3655 
     - vendorId
3656 
     - itemId
3657 
     - quantity
3658 
     - estimate
4369 rajveer 3659 
     - isReminder
4303 rajveer 3660 
    """
4369 rajveer 3661 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3662 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3663 
 
4369 rajveer 3664 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3665 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3666 
    args = markOrdersAsPORaised_args()
3667 
    args.vendorId = vendorId
3668 
    args.itemId = itemId
3669 
    args.quantity = quantity
3670 
    args.estimate = estimate
4369 rajveer 3671 
    args.isReminder = isReminder
4303 rajveer 3672 
    args.write(self._oprot)
3673 
    self._oprot.writeMessageEnd()
3674 
    self._oprot.trans.flush()
3675 
 
3676 
  def recv_markOrdersAsPORaised(self, ):
3677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3678 
    if mtype == TMessageType.EXCEPTION:
3679 
      x = TApplicationException()
3680 
      x.read(self._iprot)
3681 
      self._iprot.readMessageEnd()
3682 
      raise x
3683 
    result = markOrdersAsPORaised_result()
3684 
    result.read(self._iprot)
3685 
    self._iprot.readMessageEnd()
3686 
    if result.ex is not None:
3687 
      raise result.ex
3688 
    return
3689 
 
4369 rajveer 3690 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3691 
    """
3692 
    Parameters:
3693 
     - vendorId
3694 
     - itemId
3695 
     - quantity
3696 
     - estimate
4369 rajveer 3697 
     - isReminder
4303 rajveer 3698 
    """
4369 rajveer 3699 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3700 
    self.recv_markOrdersAsReversalInitiated()
3701 
 
4369 rajveer 3702 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3703 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3704 
    args = markOrdersAsReversalInitiated_args()
3705 
    args.vendorId = vendorId
3706 
    args.itemId = itemId
3707 
    args.quantity = quantity
3708 
    args.estimate = estimate
4369 rajveer 3709 
    args.isReminder = isReminder
4303 rajveer 3710 
    args.write(self._oprot)
3711 
    self._oprot.writeMessageEnd()
3712 
    self._oprot.trans.flush()
3713 
 
3714 
  def recv_markOrdersAsReversalInitiated(self, ):
3715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3716 
    if mtype == TMessageType.EXCEPTION:
3717 
      x = TApplicationException()
3718 
      x.read(self._iprot)
3719 
      self._iprot.readMessageEnd()
3720 
      raise x
3721 
    result = markOrdersAsReversalInitiated_result()
3722 
    result.read(self._iprot)
3723 
    self._iprot.readMessageEnd()
3724 
    if result.ex is not None:
3725 
      raise result.ex
3726 
    return
3727 
 
4369 rajveer 3728 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3729 
    """
3730 
    Parameters:
3731 
     - vendorId
3732 
     - itemId
3733 
     - quantity
3734 
     - estimate
4369 rajveer 3735 
     - isReminder
4303 rajveer 3736 
    """
4369 rajveer 3737 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3738 
    self.recv_markOrdersAsNotAvailabke()
3739 
 
4369 rajveer 3740 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3741 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3742 
    args = markOrdersAsNotAvailabke_args()
3743 
    args.vendorId = vendorId
3744 
    args.itemId = itemId
3745 
    args.quantity = quantity
3746 
    args.estimate = estimate
4369 rajveer 3747 
    args.isReminder = isReminder
4303 rajveer 3748 
    args.write(self._oprot)
3749 
    self._oprot.writeMessageEnd()
3750 
    self._oprot.trans.flush()
3751 
 
3752 
  def recv_markOrdersAsNotAvailabke(self, ):
3753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3754 
    if mtype == TMessageType.EXCEPTION:
3755 
      x = TApplicationException()
3756 
      x.read(self._iprot)
3757 
      self._iprot.readMessageEnd()
3758 
      raise x
3759 
    result = markOrdersAsNotAvailabke_result()
3760 
    result.read(self._iprot)
3761 
    self._iprot.readMessageEnd()
3762 
    if result.ex is not None:
3763 
      raise result.ex
3764 
    return
3765 
 
4369 rajveer 3766 
  def markOrdersAsTimeout(self, vendorId):
3767 
    """
3768 
    Parameters:
3769 
     - vendorId
3770 
    """
3771 
    self.send_markOrdersAsTimeout(vendorId)
3772 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3773 
 
4369 rajveer 3774 
  def send_markOrdersAsTimeout(self, vendorId):
3775 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3776 
    args = markOrdersAsTimeout_args()
3777 
    args.vendorId = vendorId
3778 
    args.write(self._oprot)
3779 
    self._oprot.writeMessageEnd()
3780 
    self._oprot.trans.flush()
3781 
 
3782 
  def recv_markOrdersAsTimeout(self, ):
3783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3784 
    if mtype == TMessageType.EXCEPTION:
3785 
      x = TApplicationException()
3786 
      x.read(self._iprot)
3787 
      self._iprot.readMessageEnd()
3788 
      raise x
3789 
    result = markOrdersAsTimeout_result()
3790 
    result.read(self._iprot)
3791 
    self._iprot.readMessageEnd()
3792 
    if result.success is not None:
3793 
      return result.success
3794 
    if result.ex is not None:
3795 
      raise result.ex
3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3797 
 
4662 rajveer 3798 
  def markOrderAsLostInTransit(self, orderId):
3799 
    """
3800 
    Mark order as LOST_IN_TRANSIT
3801 
 
3802 
    Parameters:
3803 
     - orderId
3804 
    """
3805 
    self.send_markOrderAsLostInTransit(orderId)
3806 
    return self.recv_markOrderAsLostInTransit()
3807 
 
3808 
  def send_markOrderAsLostInTransit(self, orderId):
3809 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3810 
    args = markOrderAsLostInTransit_args()
3811 
    args.orderId = orderId
3812 
    args.write(self._oprot)
3813 
    self._oprot.writeMessageEnd()
3814 
    self._oprot.trans.flush()
3815 
 
3816 
  def recv_markOrderAsLostInTransit(self, ):
3817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3818 
    if mtype == TMessageType.EXCEPTION:
3819 
      x = TApplicationException()
3820 
      x.read(self._iprot)
3821 
      self._iprot.readMessageEnd()
3822 
      raise x
3823 
    result = markOrderAsLostInTransit_result()
3824 
    result.read(self._iprot)
3825 
    self._iprot.readMessageEnd()
3826 
    if result.success is not None:
3827 
      return result.success
3828 
    if result.ex is not None:
3829 
      raise result.ex
3830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3831 
 
4386 anupam.sin 3832 
  def getOrderForAwb(self, awb):
3833 
    """
3834 
    Returns the order corresponding to an AWB number
4369 rajveer 3835 
 
4386 anupam.sin 3836 
    Parameters:
3837 
     - awb
3838 
    """
3839 
    self.send_getOrderForAwb(awb)
3840 
    return self.recv_getOrderForAwb()
3841 
 
3842 
  def send_getOrderForAwb(self, awb):
3843 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3844 
    args = getOrderForAwb_args()
3845 
    args.awb = awb
3846 
    args.write(self._oprot)
3847 
    self._oprot.writeMessageEnd()
3848 
    self._oprot.trans.flush()
3849 
 
3850 
  def recv_getOrderForAwb(self, ):
3851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3852 
    if mtype == TMessageType.EXCEPTION:
3853 
      x = TApplicationException()
3854 
      x.read(self._iprot)
3855 
      self._iprot.readMessageEnd()
3856 
      raise x
3857 
    result = getOrderForAwb_result()
3858 
    result.read(self._iprot)
3859 
    self._iprot.readMessageEnd()
3860 
    if result.success is not None:
3861 
      return result.success
3862 
    if result.ex is not None:
3863 
      raise result.ex
3864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3865 
 
4506 phani.kuma 3866 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3867 
    """
3868 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3869 
 
4506 phani.kuma 3870 
    Parameters:
3871 
     - logistics_provider_id
3872 
     - order_status
3873 
    """
3874 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3875 
    return self.recv_getOrdersForProviderForStatus()
3876 
 
3877 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3878 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3879 
    args = getOrdersForProviderForStatus_args()
3880 
    args.logistics_provider_id = logistics_provider_id
3881 
    args.order_status = order_status
3882 
    args.write(self._oprot)
3883 
    self._oprot.writeMessageEnd()
3884 
    self._oprot.trans.flush()
3885 
 
3886 
  def recv_getOrdersForProviderForStatus(self, ):
3887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3888 
    if mtype == TMessageType.EXCEPTION:
3889 
      x = TApplicationException()
3890 
      x.read(self._iprot)
3891 
      self._iprot.readMessageEnd()
3892 
      raise x
3893 
    result = getOrdersForProviderForStatus_result()
3894 
    result.read(self._iprot)
3895 
    self._iprot.readMessageEnd()
3896 
    if result.success is not None:
3897 
      return result.success
3898 
    if result.ex is not None:
3899 
      raise result.ex
3900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3901 
 
4600 varun.gupt 3902 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3903 
    """
3904 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3905 
 
4600 varun.gupt 3906 
    Parameters:
3907 
     - vendorId
3908 
     - billingDateFrom
3909 
     - billingDateTo
3910 
    """
3911 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3912 
    return self.recv_getBilledOrdersForVendor()
3913 
 
3914 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3915 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3916 
    args = getBilledOrdersForVendor_args()
3917 
    args.vendorId = vendorId
3918 
    args.billingDateFrom = billingDateFrom
3919 
    args.billingDateTo = billingDateTo
3920 
    args.write(self._oprot)
3921 
    self._oprot.writeMessageEnd()
3922 
    self._oprot.trans.flush()
3923 
 
3924 
  def recv_getBilledOrdersForVendor(self, ):
3925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3926 
    if mtype == TMessageType.EXCEPTION:
3927 
      x = TApplicationException()
3928 
      x.read(self._iprot)
3929 
      self._iprot.readMessageEnd()
3930 
      raise x
3931 
    result = getBilledOrdersForVendor_result()
3932 
    result.read(self._iprot)
3933 
    self._iprot.readMessageEnd()
3934 
    if result.success is not None:
3935 
      return result.success
3936 
    if result.ex is not None:
3937 
      raise result.ex
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3939 
 
4607 rajveer 3940 
  def getSlippedSippingDateOrders(self, ):
3941 
    self.send_getSlippedSippingDateOrders()
3942 
    return self.recv_getSlippedSippingDateOrders()
3943 
 
3944 
  def send_getSlippedSippingDateOrders(self, ):
3945 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
3946 
    args = getSlippedSippingDateOrders_args()
3947 
    args.write(self._oprot)
3948 
    self._oprot.writeMessageEnd()
3949 
    self._oprot.trans.flush()
3950 
 
3951 
  def recv_getSlippedSippingDateOrders(self, ):
3952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3953 
    if mtype == TMessageType.EXCEPTION:
3954 
      x = TApplicationException()
3955 
      x.read(self._iprot)
3956 
      self._iprot.readMessageEnd()
3957 
      raise x
3958 
    result = getSlippedSippingDateOrders_result()
3959 
    result.read(self._iprot)
3960 
    self._iprot.readMessageEnd()
3961 
    if result.success is not None:
3962 
      return result.success
3963 
    if result.ex is not None:
3964 
      raise result.ex
3965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
3966 
 
4600 varun.gupt 3967 
  def saveBluedartSettlements(self, mapAWBAndAmount):
3968 
    """
3969 
    Parameters:
3970 
     - mapAWBAndAmount
3971 
    """
3972 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
3973 
    self.recv_saveBluedartSettlements()
3974 
 
3975 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
3976 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
3977 
    args = saveBluedartSettlements_args()
3978 
    args.mapAWBAndAmount = mapAWBAndAmount
3979 
    args.write(self._oprot)
3980 
    self._oprot.writeMessageEnd()
3981 
    self._oprot.trans.flush()
3982 
 
3983 
  def recv_saveBluedartSettlements(self, ):
3984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3985 
    if mtype == TMessageType.EXCEPTION:
3986 
      x = TApplicationException()
3987 
      x.read(self._iprot)
3988 
      self._iprot.readMessageEnd()
3989 
      raise x
3990 
    result = saveBluedartSettlements_result()
3991 
    result.read(self._iprot)
3992 
    self._iprot.readMessageEnd()
3993 
    if result.ex is not None:
3994 
      raise result.ex
3995 
    return
3996 
 
3997 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3998 
    """
3999 
    Parameters:
4000 
     - settlementDate
4001 
     - paymentGatewayId
4002 
     - paymentId
4003 
     - serviceTax
4004 
     - otherCharges
4005 
     - netCollection
4006 
    """
4007 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4008 
    self.recv_savePaymentSettlements()
4009 
 
4010 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4011 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4012 
    args = savePaymentSettlements_args()
4013 
    args.settlementDate = settlementDate
4014 
    args.paymentGatewayId = paymentGatewayId
4015 
    args.paymentId = paymentId
4016 
    args.serviceTax = serviceTax
4017 
    args.otherCharges = otherCharges
4018 
    args.netCollection = netCollection
4019 
    args.write(self._oprot)
4020 
    self._oprot.writeMessageEnd()
4021 
    self._oprot.trans.flush()
4022 
 
4023 
  def recv_savePaymentSettlements(self, ):
4024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4025 
    if mtype == TMessageType.EXCEPTION:
4026 
      x = TApplicationException()
4027 
      x.read(self._iprot)
4028 
      self._iprot.readMessageEnd()
4029 
      raise x
4030 
    result = savePaymentSettlements_result()
4031 
    result.read(self._iprot)
4032 
    self._iprot.readMessageEnd()
4033 
    if result.ex is not None:
4034 
      raise result.ex
4035 
    return
4036 
 
4037 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4038 
    """
4039 
    Parameters:
4040 
     - settlementId
4041 
     - settlementDate
4042 
     - transactionDateFrom
4043 
     - transactionDateTo
4044 
     - amount
4045 
    """
4046 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4047 
    self.recv_saveEBSSettlementSummary()
4048 
 
4049 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4050 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4051 
    args = saveEBSSettlementSummary_args()
4052 
    args.settlementId = settlementId
4053 
    args.settlementDate = settlementDate
4054 
    args.transactionDateFrom = transactionDateFrom
4055 
    args.transactionDateTo = transactionDateTo
4056 
    args.amount = amount
4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_saveEBSSettlementSummary(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = saveEBSSettlementSummary_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
4071 
    if result.ex is not None:
4072 
      raise result.ex
4073 
    return
4074 
 
4075 
  def getSettlementForPaymentId(self, paymentId):
4076 
    """
4077 
    Parameters:
4078 
     - paymentId
4079 
    """
4080 
    self.send_getSettlementForPaymentId(paymentId)
4081 
    return self.recv_getSettlementForPaymentId()
4082 
 
4083 
  def send_getSettlementForPaymentId(self, paymentId):
4084 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4085 
    args = getSettlementForPaymentId_args()
4086 
    args.paymentId = paymentId
4087 
    args.write(self._oprot)
4088 
    self._oprot.writeMessageEnd()
4089 
    self._oprot.trans.flush()
4090 
 
4091 
  def recv_getSettlementForPaymentId(self, ):
4092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4093 
    if mtype == TMessageType.EXCEPTION:
4094 
      x = TApplicationException()
4095 
      x.read(self._iprot)
4096 
      self._iprot.readMessageEnd()
4097 
      raise x
4098 
    result = getSettlementForPaymentId_result()
4099 
    result.read(self._iprot)
4100 
    self._iprot.readMessageEnd()
4101 
    if result.success is not None:
4102 
      return result.success
4103 
    if result.ex is not None:
4104 
      raise result.ex
4105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4106 
 
4107 
  def getEBSSettlementSummaries(self, ):
4108 
    self.send_getEBSSettlementSummaries()
4109 
    return self.recv_getEBSSettlementSummaries()
4110 
 
4111 
  def send_getEBSSettlementSummaries(self, ):
4112 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4113 
    args = getEBSSettlementSummaries_args()
4114 
    args.write(self._oprot)
4115 
    self._oprot.writeMessageEnd()
4116 
    self._oprot.trans.flush()
4117 
 
4118 
  def recv_getEBSSettlementSummaries(self, ):
4119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4120 
    if mtype == TMessageType.EXCEPTION:
4121 
      x = TApplicationException()
4122 
      x.read(self._iprot)
4123 
      self._iprot.readMessageEnd()
4124 
      raise x
4125 
    result = getEBSSettlementSummaries_result()
4126 
    result.read(self._iprot)
4127 
    self._iprot.readMessageEnd()
4128 
    if result.success is not None:
4129 
      return result.success
4130 
    if result.ex is not None:
4131 
      raise result.ex
4132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4133 
 
4134 
  def markEBSSettlementUploaded(self, settlementId):
4135 
    """
4136 
    Parameters:
4137 
     - settlementId
4138 
    """
4139 
    self.send_markEBSSettlementUploaded(settlementId)
4140 
    self.recv_markEBSSettlementUploaded()
4141 
 
4142 
  def send_markEBSSettlementUploaded(self, settlementId):
4143 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4144 
    args = markEBSSettlementUploaded_args()
4145 
    args.settlementId = settlementId
4146 
    args.write(self._oprot)
4147 
    self._oprot.writeMessageEnd()
4148 
    self._oprot.trans.flush()
4149 
 
4150 
  def recv_markEBSSettlementUploaded(self, ):
4151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4152 
    if mtype == TMessageType.EXCEPTION:
4153 
      x = TApplicationException()
4154 
      x.read(self._iprot)
4155 
      self._iprot.readMessageEnd()
4156 
      raise x
4157 
    result = markEBSSettlementUploaded_result()
4158 
    result.read(self._iprot)
4159 
    self._iprot.readMessageEnd()
4160 
    if result.ex is not None:
4161 
      raise result.ex
4162 
    return
4163 
 
4164 
  def getEBSSettlementDate(self, settlementId):
4165 
    """
4166 
    Parameters:
4167 
     - settlementId
4168 
    """
4169 
    self.send_getEBSSettlementDate(settlementId)
4170 
    return self.recv_getEBSSettlementDate()
4171 
 
4172 
  def send_getEBSSettlementDate(self, settlementId):
4173 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4174 
    args = getEBSSettlementDate_args()
4175 
    args.settlementId = settlementId
4176 
    args.write(self._oprot)
4177 
    self._oprot.writeMessageEnd()
4178 
    self._oprot.trans.flush()
4179 
 
4180 
  def recv_getEBSSettlementDate(self, ):
4181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4182 
    if mtype == TMessageType.EXCEPTION:
4183 
      x = TApplicationException()
4184 
      x.read(self._iprot)
4185 
      self._iprot.readMessageEnd()
4186 
      raise x
4187 
    result = getEBSSettlementDate_result()
4188 
    result.read(self._iprot)
4189 
    self._iprot.readMessageEnd()
4190 
    if result.success is not None:
4191 
      return result.success
4192 
    if result.ex is not None:
4193 
      raise result.ex
4194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4195 
 
4196 
 
3376 rajveer 4197 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4198 
  def __init__(self, handler):
3376 rajveer 4199 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4200 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4201 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4202 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4203 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4204 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4205 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4206 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4207 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4208 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4209 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4210 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4211 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4212 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4213 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4214 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4215 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4216 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4217 
    self._processMap["createOrder"] = Processor.process_createOrder
4218 
    self._processMap["getOrder"] = Processor.process_getOrder
4219 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4220 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4221 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4222 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4223 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4224 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4225 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4226 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4227 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4228 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4229 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4230 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4231 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4232 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4233 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4234 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4235 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4236 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4237 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4238 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4239 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4240 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4241 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4242 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4243 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4244 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4245 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4246 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4247 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4248 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4249 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4250 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4251 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4252 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4253 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4254 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4255 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4256 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4257 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4258 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4259 
    self._processMap["changeItem"] = Processor.process_changeItem
4260 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4261 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4262 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4263 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4264 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4265 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4266 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4267 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4268 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4269 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4270 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4271 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4272 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4273 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4274 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4275 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4276 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4277 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4278 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4279 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4280 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4281 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4282 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4600 varun.gupt 4283 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4284 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4285 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4286 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4287 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4288 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4289 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4290 
 
4291 
  def process(self, iprot, oprot):
4292 
    (name, type, seqid) = iprot.readMessageBegin()
4293 
    if name not in self._processMap:
4294 
      iprot.skip(TType.STRUCT)
4295 
      iprot.readMessageEnd()
4296 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4297 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4298 
      x.write(oprot)
4299 
      oprot.writeMessageEnd()
4300 
      oprot.trans.flush()
4301 
      return
4302 
    else:
4303 
      self._processMap[name](self, seqid, iprot, oprot)
4304 
    return True
4305 
 
4306 
  def process_createTransaction(self, seqid, iprot, oprot):
4307 
    args = createTransaction_args()
4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
4310 
    result = createTransaction_result()
4311 
    try:
132 ashish 4312 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4313 
    except TransactionServiceException, ex:
4314 
      result.ex = ex
4315 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
4320 
  def process_getTransaction(self, seqid, iprot, oprot):
4321 
    args = getTransaction_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = getTransaction_result()
4325 
    try:
4326 
      result.success = self._handler.getTransaction(args.id)
4327 
    except TransactionServiceException, ex:
4328 
      result.ex = ex
4329 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
4333 
 
4334 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4335 
    args = getTransactionsForCustomer_args()
4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
4338 
    result = getTransactionsForCustomer_result()
4339 
    try:
4340 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4341 
    except TransactionServiceException, ex:
4342 
      result.ex = ex
4343 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4344 
    result.write(oprot)
4345 
    oprot.writeMessageEnd()
4346 
    oprot.trans.flush()
4347 
 
132 ashish 4348 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4349 
    args = getTransactionsForShoppingCartId_args()
4350 
    args.read(iprot)
4351 
    iprot.readMessageEnd()
4352 
    result = getTransactionsForShoppingCartId_result()
4353 
    try:
4354 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4355 
    except TransactionServiceException, ex:
4356 
      result.ex = ex
4357 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4358 
    result.write(oprot)
4359 
    oprot.writeMessageEnd()
4360 
    oprot.trans.flush()
4361 
 
94 ashish 4362 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4363 
    args = getTransactionStatus_args()
4364 
    args.read(iprot)
4365 
    iprot.readMessageEnd()
4366 
    result = getTransactionStatus_result()
4367 
    try:
4368 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4369 
    except TransactionServiceException, ex:
4370 
      result.ex = ex
4371 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4372 
    result.write(oprot)
4373 
    oprot.writeMessageEnd()
4374 
    oprot.trans.flush()
4375 
 
4376 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4377 
    args = changeTransactionStatus_args()
4378 
    args.read(iprot)
4379 
    iprot.readMessageEnd()
4380 
    result = changeTransactionStatus_result()
4381 
    try:
4382 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4383 
    except TransactionServiceException, ex:
4384 
      result.ex = ex
4385 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4386 
    result.write(oprot)
4387 
    oprot.writeMessageEnd()
4388 
    oprot.trans.flush()
4389 
 
1398 varun.gupt 4390 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4391 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4392 
    args.read(iprot)
4393 
    iprot.readMessageEnd()
1398 varun.gupt 4394 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4395 
    try:
1398 varun.gupt 4396 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4397 
    except TransactionServiceException, ex:
4398 
      result.ex = ex
1398 varun.gupt 4399 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4400 
    result.write(oprot)
4401 
    oprot.writeMessageEnd()
4402 
    oprot.trans.flush()
4403 
 
483 rajveer 4404 
  def process_getAllOrders(self, seqid, iprot, oprot):
4405 
    args = getAllOrders_args()
94 ashish 4406 
    args.read(iprot)
4407 
    iprot.readMessageEnd()
483 rajveer 4408 
    result = getAllOrders_result()
94 ashish 4409 
    try:
483 rajveer 4410 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4411 
    except TransactionServiceException, ex:
4412 
      result.ex = ex
483 rajveer 4413 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
4417 
 
4133 chandransh 4418 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4419 
    args = getOrdersInBatch_args()
4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
4422 
    result = getOrdersInBatch_result()
4423 
    try:
4424 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4425 
    except TransactionServiceException, ex:
4426 
      result.ex = ex
4427 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4428 
    result.write(oprot)
4429 
    oprot.writeMessageEnd()
4430 
    oprot.trans.flush()
4431 
 
4432 
  def process_getOrderCount(self, seqid, iprot, oprot):
4433 
    args = getOrderCount_args()
4434 
    args.read(iprot)
4435 
    iprot.readMessageEnd()
4436 
    result = getOrderCount_result()
4437 
    try:
4438 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4439 
    except TransactionServiceException, ex:
4440 
      result.ex = ex
4441 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4442 
    result.write(oprot)
4443 
    oprot.writeMessageEnd()
4444 
    oprot.trans.flush()
4445 
 
999 varun.gupt 4446 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4447 
    args = getOrdersByBillingDate_args()
4448 
    args.read(iprot)
4449 
    iprot.readMessageEnd()
4450 
    result = getOrdersByBillingDate_result()
4451 
    try:
4452 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4453 
    except TransactionServiceException, ex:
4454 
      result.ex = ex
4455 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4456 
    result.write(oprot)
4457 
    oprot.writeMessageEnd()
4458 
    oprot.trans.flush()
4459 
 
3427 chandransh 4460 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4461 
    args = getOrdersByShippingDate_args()
4462 
    args.read(iprot)
4463 
    iprot.readMessageEnd()
4464 
    result = getOrdersByShippingDate_result()
4465 
    try:
3451 chandransh 4466 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4467 
    except TransactionServiceException, ex:
4468 
      result.ex = ex
4469 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4470 
    result.write(oprot)
4471 
    oprot.writeMessageEnd()
4472 
    oprot.trans.flush()
4473 
 
1382 varun.gupt 4474 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4475 
    args = getReturnableOrdersForCustomer_args()
4476 
    args.read(iprot)
4477 
    iprot.readMessageEnd()
4478 
    result = getReturnableOrdersForCustomer_result()
4479 
    try:
4480 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4481 
    except TransactionServiceException, ex:
4482 
      result.ex = ex
4483 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
4487 
 
4488 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4489 
    args = getCancellableOrdersForCustomer_args()
4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
4492 
    result = getCancellableOrdersForCustomer_result()
4493 
    try:
4494 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4495 
    except TransactionServiceException, ex:
4496 
      result.ex = ex
4497 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4498 
    result.write(oprot)
4499 
    oprot.writeMessageEnd()
4500 
    oprot.trans.flush()
4501 
 
483 rajveer 4502 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4503 
    args = changeOrderStatus_args()
94 ashish 4504 
    args.read(iprot)
4505 
    iprot.readMessageEnd()
483 rajveer 4506 
    result = changeOrderStatus_result()
94 ashish 4507 
    try:
483 rajveer 4508 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4509 
    except TransactionServiceException, ex:
4510 
      result.ex = ex
483 rajveer 4511 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4512 
    result.write(oprot)
4513 
    oprot.writeMessageEnd()
4514 
    oprot.trans.flush()
4515 
 
483 rajveer 4516 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4517 
    args = getOrdersForTransaction_args()
94 ashish 4518 
    args.read(iprot)
4519 
    iprot.readMessageEnd()
483 rajveer 4520 
    result = getOrdersForTransaction_result()
94 ashish 4521 
    try:
1528 ankur.sing 4522 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4523 
    except TransactionServiceException, ex:
4524 
      result.ex = ex
483 rajveer 4525 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4526 
    result.write(oprot)
4527 
    oprot.writeMessageEnd()
4528 
    oprot.trans.flush()
4529 
 
483 rajveer 4530 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4531 
    args = getOrdersForCustomer_args()
94 ashish 4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
483 rajveer 4534 
    result = getOrdersForCustomer_result()
94 ashish 4535 
    try:
3014 chandransh 4536 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4537 
    except TransactionServiceException, ex:
4538 
      result.ex = ex
483 rajveer 4539 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
483 rajveer 4544 
  def process_createOrder(self, seqid, iprot, oprot):
4545 
    args = createOrder_args()
94 ashish 4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
483 rajveer 4548 
    result = createOrder_result()
94 ashish 4549 
    try:
483 rajveer 4550 
      result.success = self._handler.createOrder(args.order)
94 ashish 4551 
    except TransactionServiceException, ex:
4552 
      result.ex = ex
483 rajveer 4553 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4554 
    result.write(oprot)
4555 
    oprot.writeMessageEnd()
4556 
    oprot.trans.flush()
4557 
 
483 rajveer 4558 
  def process_getOrder(self, seqid, iprot, oprot):
4559 
    args = getOrder_args()
94 ashish 4560 
    args.read(iprot)
4561 
    iprot.readMessageEnd()
483 rajveer 4562 
    result = getOrder_result()
94 ashish 4563 
    try:
483 rajveer 4564 
      result.success = self._handler.getOrder(args.id)
94 ashish 4565 
    except TransactionServiceException, ex:
4566 
      result.ex = ex
483 rajveer 4567 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4568 
    result.write(oprot)
4569 
    oprot.writeMessageEnd()
4570 
    oprot.trans.flush()
4571 
 
483 rajveer 4572 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4573 
    args = getLineItemsForOrder_args()
94 ashish 4574 
    args.read(iprot)
4575 
    iprot.readMessageEnd()
483 rajveer 4576 
    result = getLineItemsForOrder_result()
94 ashish 4577 
    try:
483 rajveer 4578 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4579 
    except TransactionServiceException, ex:
4580 
      result.ex = ex
483 rajveer 4581 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
1528 ankur.sing 4586 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4587 
    args = getOrderForCustomer_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = getOrderForCustomer_result()
4591 
    try:
4592 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4593 
    except TransactionServiceException, ex:
4594 
      result.ex = ex
4595 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4599 
 
3064 chandransh 4600 
  def process_getAlerts(self, seqid, iprot, oprot):
4601 
    args = getAlerts_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = getAlerts_result()
4444 rajveer 4605 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4606 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4394 rajveer 4611 
  def process_addAlert(self, seqid, iprot, oprot):
4612 
    args = addAlert_args()
3064 chandransh 4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4394 rajveer 4615 
    result = addAlert_result()
4444 rajveer 4616 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4617 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
4444 rajveer 4622 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4623 
    args = markAlertsAsSeen_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = markAlertsAsSeen_result()
4627 
    self._handler.markAlertsAsSeen(args.warehouseId)
4628 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
3064 chandransh 4633 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4634 
    args = getValidOrderCount_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = getValidOrderCount_result()
4638 
    result.success = self._handler.getValidOrderCount()
4639 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
4644 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4645 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4649 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4650 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
4655 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4656 
    args = getValidOrdersAmountRange_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = getValidOrdersAmountRange_result()
4660 
    result.success = self._handler.getValidOrdersAmountRange()
4661 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4666 
  def process_getValidOrders(self, seqid, iprot, oprot):
4667 
    args = getValidOrders_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = getValidOrders_result()
4671 
    result.success = self._handler.getValidOrders(args.limit)
4672 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4673 
    result.write(oprot)
4674 
    oprot.writeMessageEnd()
4675 
    oprot.trans.flush()
4676 
 
1220 chandransh 4677 
  def process_batchOrders(self, seqid, iprot, oprot):
4678 
    args = batchOrders_args()
4679 
    args.read(iprot)
4680 
    iprot.readMessageEnd()
4681 
    result = batchOrders_result()
4682 
    try:
4683 
      result.success = self._handler.batchOrders(args.warehouseId)
4684 
    except TransactionServiceException, ex:
4685 
      result.ex = ex
4686 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4687 
    result.write(oprot)
4688 
    oprot.writeMessageEnd()
4689 
    oprot.trans.flush()
4690 
 
1208 chandransh 4691 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4692 
    args = markOrderAsOutOfStock_args()
4693 
    args.read(iprot)
4694 
    iprot.readMessageEnd()
4695 
    result = markOrderAsOutOfStock_result()
4696 
    try:
4697 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4698 
    except TransactionServiceException, ex:
4699 
      result.ex = ex
4700 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4701 
    result.write(oprot)
4702 
    oprot.writeMessageEnd()
4703 
    oprot.trans.flush()
4704 
 
3064 chandransh 4705 
  def process_verifyOrder(self, seqid, iprot, oprot):
4706 
    args = verifyOrder_args()
759 chandransh 4707 
    args.read(iprot)
4708 
    iprot.readMessageEnd()
3064 chandransh 4709 
    result = verifyOrder_result()
759 chandransh 4710 
    try:
3064 chandransh 4711 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4712 
    except TransactionServiceException, ex:
4713 
      result.ex = ex
3064 chandransh 4714 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4715 
    result.write(oprot)
4716 
    oprot.writeMessageEnd()
4717 
    oprot.trans.flush()
4718 
 
3064 chandransh 4719 
  def process_acceptOrder(self, seqid, iprot, oprot):
4720 
    args = acceptOrder_args()
1113 chandransh 4721 
    args.read(iprot)
4722 
    iprot.readMessageEnd()
3064 chandransh 4723 
    result = acceptOrder_result()
1113 chandransh 4724 
    try:
3064 chandransh 4725 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4726 
    except TransactionServiceException, ex:
4727 
      result.ex = ex
3064 chandransh 4728 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4729 
    result.write(oprot)
4730 
    oprot.writeMessageEnd()
4731 
    oprot.trans.flush()
4732 
 
3064 chandransh 4733 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4734 
    args = addBillingDetails_args()
1135 chandransh 4735 
    args.read(iprot)
4736 
    iprot.readMessageEnd()
3064 chandransh 4737 
    result = addBillingDetails_result()
1135 chandransh 4738 
    try:
4658 mandeep.dh 4739 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4740 
    except TransactionServiceException, ex:
4741 
      result.ex = ex
3064 chandransh 4742 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4743 
    result.write(oprot)
4744 
    oprot.writeMessageEnd()
4745 
    oprot.trans.flush()
4746 
 
4579 rajveer 4747 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4748 
    args = addInvoiceNumber_args()
4749 
    args.read(iprot)
4750 
    iprot.readMessageEnd()
4751 
    result = addInvoiceNumber_result()
4752 
    try:
4753 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4754 
    except TransactionServiceException, ex:
4755 
      result.ex = ex
4756 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4757 
    result.write(oprot)
4758 
    oprot.writeMessageEnd()
4759 
    oprot.trans.flush()
4760 
 
3064 chandransh 4761 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4762 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4763 
    args.read(iprot)
4764 
    iprot.readMessageEnd()
3064 chandransh 4765 
    result = markOrdersAsManifested_result()
4766 
    try:
4767 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4768 
    except TransactionServiceException, ex:
4769 
      result.ex = ex
4770 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
4410 rajveer 4775 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4776 
    args = markOrdersAsShippedFromWarehouse_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = markOrdersAsShippedFromWarehouse_result()
4780 
    try:
4781 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4782 
    except TransactionServiceException, ex:
4783 
      result.ex = ex
4784 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4785 
    result.write(oprot)
4786 
    oprot.writeMessageEnd()
4787 
    oprot.trans.flush()
4788 
 
3064 chandransh 4789 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4790 
    args = markOrdersAsPickedUp_args()
304 ashish 4791 
    args.read(iprot)
4792 
    iprot.readMessageEnd()
3064 chandransh 4793 
    result = markOrdersAsPickedUp_result()
4794 
    try:
4795 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4796 
    except TransactionServiceException, ex:
4797 
      result.ex = ex
4798 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
94 ashish 4802 
 
3064 chandransh 4803 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4804 
    args = markOrdersAsDelivered_args()
304 ashish 4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
3064 chandransh 4807 
    result = markOrdersAsDelivered_result()
4808 
    try:
4809 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4810 
    except TransactionServiceException, ex:
4811 
      result.ex = ex
4812 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
3064 chandransh 4817 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4818 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
3064 chandransh 4821 
    result = markOrdersAsFailed_result()
4822 
    try:
4823 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4824 
    except TransactionServiceException, ex:
4825 
      result.ex = ex
4826 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4827 
    result.write(oprot)
4828 
    oprot.writeMessageEnd()
4829 
    oprot.trans.flush()
304 ashish 4830 
 
3064 chandransh 4831 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4832 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4833 
    args.read(iprot)
4834 
    iprot.readMessageEnd()
3064 chandransh 4835 
    result = updateNonDeliveryReason_result()
4836 
    try:
4581 phani.kuma 4837 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4838 
    except TransactionServiceException, ex:
4839 
      result.ex = ex
4840 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
1596 ankur.sing 4844 
 
3064 chandransh 4845 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4846 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
3064 chandransh 4849 
    result = getUndeliveredOrders_result()
4850 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4851 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4852 
    result.write(oprot)
4853 
    oprot.writeMessageEnd()
4854 
    oprot.trans.flush()
4855 
 
2536 chandransh 4856 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4857 
    args = toggleDOAFlag_args()
4858 
    args.read(iprot)
4859 
    iprot.readMessageEnd()
4860 
    result = toggleDOAFlag_result()
4861 
    try:
4862 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4863 
    except TransactionServiceException, ex:
4864 
      result.ex = ex
4865 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4866 
    result.write(oprot)
4867 
    oprot.writeMessageEnd()
4868 
    oprot.trans.flush()
1886 ankur.sing 4869 
 
4454 rajveer 4870 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4871 
    args = markOrderDoaRequestReceived_args()
4872 
    args.read(iprot)
4873 
    iprot.readMessageEnd()
4874 
    result = markOrderDoaRequestReceived_result()
4875 
    try:
4876 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4877 
    except TransactionServiceException, ex:
4878 
      result.ex = ex
4879 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4880 
    result.write(oprot)
4881 
    oprot.writeMessageEnd()
4882 
    oprot.trans.flush()
4883 
 
4884 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4885 
    args = markOrderDoaRequestAuthorized_args()
4886 
    args.read(iprot)
4887 
    iprot.readMessageEnd()
4888 
    result = markOrderDoaRequestAuthorized_result()
4889 
    try:
4890 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4891 
    except TransactionServiceException, ex:
4892 
      result.ex = ex
4893 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4894 
    result.write(oprot)
4895 
    oprot.writeMessageEnd()
4896 
    oprot.trans.flush()
4897 
 
4488 rajveer 4898 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4899 
    args = markOrderReturnRequestReceived_args()
4900 
    args.read(iprot)
4901 
    iprot.readMessageEnd()
4902 
    result = markOrderReturnRequestReceived_result()
4903 
    try:
4904 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4905 
    except TransactionServiceException, ex:
4906 
      result.ex = ex
4907 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4908 
    result.write(oprot)
4909 
    oprot.writeMessageEnd()
4910 
    oprot.trans.flush()
4911 
 
4912 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4913 
    args = markOrderReturnRequestAuthorized_args()
4914 
    args.read(iprot)
4915 
    iprot.readMessageEnd()
4916 
    result = markOrderReturnRequestAuthorized_result()
4917 
    try:
4918 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4919 
    except TransactionServiceException, ex:
4920 
      result.ex = ex
4921 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4922 
    result.write(oprot)
4923 
    oprot.writeMessageEnd()
4924 
    oprot.trans.flush()
4925 
 
2536 chandransh 4926 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4927 
    args = requestPickupNumber_args()
4928 
    args.read(iprot)
4929 
    iprot.readMessageEnd()
4930 
    result = requestPickupNumber_result()
4931 
    try:
4579 rajveer 4932 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4933 
    except TransactionServiceException, ex:
4934 
      result.ex = ex
4935 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
4939 
 
4940 
  def process_authorizePickup(self, seqid, iprot, oprot):
4941 
    args = authorizePickup_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = authorizePickup_result()
4945 
    try:
4602 rajveer 4946 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 4947 
    except TransactionServiceException, ex:
4948 
      result.ex = ex
4949 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
2764 chandransh 4954 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4955 
    args = markDoasAsPickedUp_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = markDoasAsPickedUp_result()
4959 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4960 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
2616 chandransh 4965 
  def process_receiveReturn(self, seqid, iprot, oprot):
4966 
    args = receiveReturn_args()
2591 chandransh 4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
2616 chandransh 4969 
    result = receiveReturn_result()
2591 chandransh 4970 
    try:
4479 rajveer 4971 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4972 
    except TransactionServiceException, ex:
4973 
      result.ex = ex
2616 chandransh 4974 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
2536 chandransh 4978 
 
2591 chandransh 4979 
  def process_validateDoa(self, seqid, iprot, oprot):
4980 
    args = validateDoa_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = validateDoa_result()
4984 
    try:
4985 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4986 
    except TransactionServiceException, ex:
4987 
      result.ex = ex
4988 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
4495 rajveer 4993 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4994 
    args = validateReturnProduct_args()
4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
4997 
    result = validateReturnProduct_result()
4998 
    try:
4999 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5000 
    except TransactionServiceException, ex:
5001 
      result.ex = ex
5002 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
2616 chandransh 5007 
  def process_reshipOrder(self, seqid, iprot, oprot):
5008 
    args = reshipOrder_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = reshipOrder_result()
5012 
    try:
5013 
      result.success = self._handler.reshipOrder(args.orderId)
5014 
    except TransactionServiceException, ex:
5015 
      result.ex = ex
5016 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
2591 chandransh 5020 
 
2616 chandransh 5021 
  def process_refundOrder(self, seqid, iprot, oprot):
5022 
    args = refundOrder_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = refundOrder_result()
5026 
    try:
3226 chandransh 5027 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5028 
    except TransactionServiceException, ex:
5029 
      result.ex = ex
5030 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
2690 chandransh 5035 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5036 
    args = getReturnOrders_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = getReturnOrders_result()
5040 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5041 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5042 
    result.write(oprot)
5043 
    oprot.writeMessageEnd()
5044 
    oprot.trans.flush()
2616 chandransh 5045 
 
2700 chandransh 5046 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5047 
    args = getReturnOrder_args()
5048 
    args.read(iprot)
5049 
    iprot.readMessageEnd()
5050 
    result = getReturnOrder_result()
5051 
    try:
5052 
      result.success = self._handler.getReturnOrder(args.id)
5053 
    except TransactionServiceException, ex:
5054 
      result.ex = ex
5055 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5056 
    result.write(oprot)
5057 
    oprot.writeMessageEnd()
5058 
    oprot.trans.flush()
5059 
 
2690 chandransh 5060 
  def process_processReturn(self, seqid, iprot, oprot):
5061 
    args = processReturn_args()
5062 
    args.read(iprot)
5063 
    iprot.readMessageEnd()
5064 
    result = processReturn_result()
5065 
    try:
5066 
      self._handler.processReturn(args.returnOrderId)
5067 
    except TransactionServiceException, ex:
5068 
      result.ex = ex
5069 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
5073 
 
2819 chandransh 5074 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5075 
    args = createPurchaseOrder_args()
5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
5078 
    result = createPurchaseOrder_result()
5079 
    try:
5080 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5081 
    except TransactionServiceException, ex:
5082 
      result.ex = ex
5083 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5084 
    result.write(oprot)
5085 
    oprot.writeMessageEnd()
5086 
    oprot.trans.flush()
2690 chandransh 5087 
 
3451 chandransh 5088 
  def process_updateWeight(self, seqid, iprot, oprot):
5089 
    args = updateWeight_args()
5090 
    args.read(iprot)
5091 
    iprot.readMessageEnd()
5092 
    result = updateWeight_result()
5093 
    try:
5094 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5095 
    except TransactionServiceException, ex:
5096 
      result.ex = ex
5097 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
2819 chandransh 5101 
 
3469 chandransh 5102 
  def process_changeItem(self, seqid, iprot, oprot):
5103 
    args = changeItem_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = changeItem_result()
5107 
    try:
5108 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5109 
    except TransactionServiceException, ex:
5110 
      result.ex = ex
5111 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5112 
    result.write(oprot)
5113 
    oprot.writeMessageEnd()
5114 
    oprot.trans.flush()
3451 chandransh 5115 
 
3469 chandransh 5116 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5117 
    args = shiftToWarehouse_args()
5118 
    args.read(iprot)
5119 
    iprot.readMessageEnd()
5120 
    result = shiftToWarehouse_result()
5121 
    try:
5122 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5123 
    except TransactionServiceException, ex:
5124 
      result.ex = ex
5125 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
3553 chandransh 5130 
  def process_addDelayReason(self, seqid, iprot, oprot):
5131 
    args = addDelayReason_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = addDelayReason_result()
5135 
    try:
4647 rajveer 5136 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5137 
    except TransactionServiceException, ex:
5138 
      result.ex = ex
5139 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
3469 chandransh 5143 
 
3956 chandransh 5144 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5145 
    args = reconcileCodCollection_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = reconcileCodCollection_result()
5149 
    try:
5150 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5151 
    except TransactionServiceException, ex:
5152 
      result.ex = ex
5153 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5154 
    result.write(oprot)
5155 
    oprot.writeMessageEnd()
5156 
    oprot.trans.flush()
3553 chandransh 5157 
 
4008 mandeep.dh 5158 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5159 
    args = getTransactionsRequiringExtraProcessing_args()
5160 
    args.read(iprot)
5161 
    iprot.readMessageEnd()
5162 
    result = getTransactionsRequiringExtraProcessing_result()
5163 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5164 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5165 
    result.write(oprot)
5166 
    oprot.writeMessageEnd()
5167 
    oprot.trans.flush()
3956 chandransh 5168 
 
4008 mandeep.dh 5169 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5170 
    args = markTransactionAsProcessed_args()
5171 
    args.read(iprot)
5172 
    iprot.readMessageEnd()
5173 
    result = markTransactionAsProcessed_result()
5174 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5175 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
4018 chandransh 5180 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5181 
    args = getItemWiseRiskyOrdersCount_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = getItemWiseRiskyOrdersCount_result()
5185 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5186 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5187 
    result.write(oprot)
5188 
    oprot.writeMessageEnd()
5189 
    oprot.trans.flush()
4008 mandeep.dh 5190 
 
4295 varun.gupt 5191 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5192 
    args = getOrdersForItemIds_args()
5193 
    args.read(iprot)
5194 
    iprot.readMessageEnd()
5195 
    result = getOrdersForItemIds_result()
5196 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5197 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5198 
    result.write(oprot)
5199 
    oprot.writeMessageEnd()
5200 
    oprot.trans.flush()
5201 
 
4247 rajveer 5202 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5203 
    args = markOrderCancellationRequestReceived_args()
5204 
    args.read(iprot)
5205 
    iprot.readMessageEnd()
5206 
    result = markOrderCancellationRequestReceived_result()
5207 
    try:
5208 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5209 
    except TransactionServiceException, ex:
5210 
      result.ex = ex
5211 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
4018 chandransh 5215 
 
4247 rajveer 5216 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5217 
    args = markOrderCancellationRequestConfirmed_args()
5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
5220 
    result = markOrderCancellationRequestConfirmed_result()
5221 
    try:
5222 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5223 
    except TransactionServiceException, ex:
5224 
      result.ex = ex
5225 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
5229 
 
5230 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5231 
    args = markOrderCancellationRequestDenied_args()
5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
5234 
    result = markOrderCancellationRequestDenied_result()
5235 
    try:
5236 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5237 
    except TransactionServiceException, ex:
5238 
      result.ex = ex
5239 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5240 
    result.write(oprot)
5241 
    oprot.writeMessageEnd()
5242 
    oprot.trans.flush()
5243 
 
4258 rajveer 5244 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5245 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5246 
    args.read(iprot)
5247 
    iprot.readMessageEnd()
4258 rajveer 5248 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5249 
    try:
4258 rajveer 5250 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5251 
    except TransactionServiceException, ex:
5252 
      result.ex = ex
4258 rajveer 5253 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5254 
    result.write(oprot)
5255 
    oprot.writeMessageEnd()
5256 
    oprot.trans.flush()
5257 
 
4259 anupam.sin 5258 
  def process_refundTransaction(self, seqid, iprot, oprot):
5259 
    args = refundTransaction_args()
5260 
    args.read(iprot)
5261 
    iprot.readMessageEnd()
5262 
    result = refundTransaction_result()
5263 
    try:
5264 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5265 
    except TransactionServiceException, ex:
5266 
      result.ex = ex
5267 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
4247 rajveer 5271 
 
4324 mandeep.dh 5272 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5273 
    args = updateShipmentAddress_args()
5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
5276 
    result = updateShipmentAddress_result()
5277 
    try:
5278 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
5281 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
4285 rajveer 5286 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5287 
    args = acceptOrdersForItemId_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = acceptOrdersForItemId_result()
5291 
    try:
5292 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5293 
    except TransactionServiceException, ex:
5294 
      result.ex = ex
5295 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
4259 anupam.sin 5299 
 
4303 rajveer 5300 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5301 
    args = markOrdersAsPORaised_args()
5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
5304 
    result = markOrdersAsPORaised_result()
5305 
    try:
4369 rajveer 5306 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5307 
    except TransactionServiceException, ex:
5308 
      result.ex = ex
5309 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
4285 rajveer 5313 
 
4303 rajveer 5314 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5315 
    args = markOrdersAsReversalInitiated_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = markOrdersAsReversalInitiated_result()
5319 
    try:
4369 rajveer 5320 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5321 
    except TransactionServiceException, ex:
5322 
      result.ex = ex
5323 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5324 
    result.write(oprot)
5325 
    oprot.writeMessageEnd()
5326 
    oprot.trans.flush()
5327 
 
5328 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5329 
    args = markOrdersAsNotAvailabke_args()
5330 
    args.read(iprot)
5331 
    iprot.readMessageEnd()
5332 
    result = markOrdersAsNotAvailabke_result()
5333 
    try:
4369 rajveer 5334 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5335 
    except TransactionServiceException, ex:
5336 
      result.ex = ex
5337 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5338 
    result.write(oprot)
5339 
    oprot.writeMessageEnd()
5340 
    oprot.trans.flush()
5341 
 
4369 rajveer 5342 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5343 
    args = markOrdersAsTimeout_args()
5344 
    args.read(iprot)
5345 
    iprot.readMessageEnd()
5346 
    result = markOrdersAsTimeout_result()
5347 
    try:
5348 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5349 
    except TransactionServiceException, ex:
5350 
      result.ex = ex
5351 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
4303 rajveer 5355 
 
4662 rajveer 5356 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5357 
    args = markOrderAsLostInTransit_args()
5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
5360 
    result = markOrderAsLostInTransit_result()
5361 
    try:
5362 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5363 
    except TransactionServiceException, ex:
5364 
      result.ex = ex
5365 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
5369 
 
4386 anupam.sin 5370 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5371 
    args = getOrderForAwb_args()
5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
5374 
    result = getOrderForAwb_result()
5375 
    try:
5376 
      result.success = self._handler.getOrderForAwb(args.awb)
5377 
    except TransactionServiceException, ex:
5378 
      result.ex = ex
5379 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
4369 rajveer 5383 
 
4506 phani.kuma 5384 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5385 
    args = getOrdersForProviderForStatus_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = getOrdersForProviderForStatus_result()
5389 
    try:
5390 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5391 
    except TransactionServiceException, ex:
5392 
      result.ex = ex
5393 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
4386 anupam.sin 5397 
 
4600 varun.gupt 5398 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5399 
    args = getBilledOrdersForVendor_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = getBilledOrdersForVendor_result()
5403 
    try:
5404 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5405 
    except TransactionServiceException, ex:
5406 
      result.ex = ex
5407 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
4506 phani.kuma 5411 
 
4607 rajveer 5412 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5413 
    args = getSlippedSippingDateOrders_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = getSlippedSippingDateOrders_result()
5417 
    try:
5418 
      result.success = self._handler.getSlippedSippingDateOrders()
5419 
    except TransactionServiceException, ex:
5420 
      result.ex = ex
5421 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
4600 varun.gupt 5426 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5427 
    args = saveBluedartSettlements_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = saveBluedartSettlements_result()
5431 
    try:
5432 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5433 
    except TransactionServiceException, ex:
5434 
      result.ex = ex
5435 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
5439 
 
5440 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5441 
    args = savePaymentSettlements_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = savePaymentSettlements_result()
5445 
    try:
5446 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5447 
    except TransactionServiceException, ex:
5448 
      result.ex = ex
5449 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
5453 
 
5454 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5455 
    args = saveEBSSettlementSummary_args()
5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
5458 
    result = saveEBSSettlementSummary_result()
5459 
    try:
5460 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5461 
    except TransactionServiceException, ex:
5462 
      result.ex = ex
5463 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5464 
    result.write(oprot)
5465 
    oprot.writeMessageEnd()
5466 
    oprot.trans.flush()
5467 
 
5468 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5469 
    args = getSettlementForPaymentId_args()
5470 
    args.read(iprot)
5471 
    iprot.readMessageEnd()
5472 
    result = getSettlementForPaymentId_result()
5473 
    try:
5474 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5475 
    except TransactionServiceException, ex:
5476 
      result.ex = ex
5477 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
5481 
 
5482 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5483 
    args = getEBSSettlementSummaries_args()
5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
5486 
    result = getEBSSettlementSummaries_result()
5487 
    try:
5488 
      result.success = self._handler.getEBSSettlementSummaries()
5489 
    except TransactionServiceException, ex:
5490 
      result.ex = ex
5491 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5492 
    result.write(oprot)
5493 
    oprot.writeMessageEnd()
5494 
    oprot.trans.flush()
5495 
 
5496 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5497 
    args = markEBSSettlementUploaded_args()
5498 
    args.read(iprot)
5499 
    iprot.readMessageEnd()
5500 
    result = markEBSSettlementUploaded_result()
5501 
    try:
5502 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5503 
    except TransactionServiceException, ex:
5504 
      result.ex = ex
5505 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5506 
    result.write(oprot)
5507 
    oprot.writeMessageEnd()
5508 
    oprot.trans.flush()
5509 
 
5510 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5511 
    args = getEBSSettlementDate_args()
5512 
    args.read(iprot)
5513 
    iprot.readMessageEnd()
5514 
    result = getEBSSettlementDate_result()
5515 
    try:
5516 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5517 
    except TransactionServiceException, ex:
5518 
      result.ex = ex
5519 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5520 
    result.write(oprot)
5521 
    oprot.writeMessageEnd()
5522 
    oprot.trans.flush()
5523 
 
5524 
 
94 ashish 5525 
# HELPER FUNCTIONS AND STRUCTURES
5526 
 
5527 
class createTransaction_args:
5528 
  """
5529 
  Attributes:
5530 
   - transaction
5531 
  """
5532 
 
5533 
  thrift_spec = (
5534 
    None, # 0
5535 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5536 
  )
5537 
 
5538 
  def __init__(self, transaction=None,):
5539 
    self.transaction = transaction
5540 
 
5541 
  def read(self, iprot):
5542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5544 
      return
5545 
    iprot.readStructBegin()
5546 
    while True:
5547 
      (fname, ftype, fid) = iprot.readFieldBegin()
5548 
      if ftype == TType.STOP:
5549 
        break
5550 
      if fid == 1:
5551 
        if ftype == TType.STRUCT:
5552 
          self.transaction = Transaction()
5553 
          self.transaction.read(iprot)
5554 
        else:
5555 
          iprot.skip(ftype)
5556 
      else:
5557 
        iprot.skip(ftype)
5558 
      iprot.readFieldEnd()
5559 
    iprot.readStructEnd()
5560 
 
5561 
  def write(self, oprot):
5562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5564 
      return
5565 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5566 
    if self.transaction is not None:
94 ashish 5567 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5568 
      self.transaction.write(oprot)
5569 
      oprot.writeFieldEnd()
5570 
    oprot.writeFieldStop()
5571 
    oprot.writeStructEnd()
5572 
 
3431 rajveer 5573 
  def validate(self):
5574 
    return
5575 
 
5576 
 
94 ashish 5577 
  def __repr__(self):
5578 
    L = ['%s=%r' % (key, value)
5579 
      for key, value in self.__dict__.iteritems()]
5580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5581 
 
5582 
  def __eq__(self, other):
5583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5584 
 
5585 
  def __ne__(self, other):
5586 
    return not (self == other)
5587 
 
5588 
class createTransaction_result:
5589 
  """
5590 
  Attributes:
132 ashish 5591 
   - success
94 ashish 5592 
   - ex
5593 
  """
5594 
 
5595 
  thrift_spec = (
132 ashish 5596 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5598 
  )
5599 
 
132 ashish 5600 
  def __init__(self, success=None, ex=None,):
5601 
    self.success = success
94 ashish 5602 
    self.ex = ex
5603 
 
5604 
  def read(self, iprot):
5605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5607 
      return
5608 
    iprot.readStructBegin()
5609 
    while True:
5610 
      (fname, ftype, fid) = iprot.readFieldBegin()
5611 
      if ftype == TType.STOP:
5612 
        break
132 ashish 5613 
      if fid == 0:
5614 
        if ftype == TType.I64:
5615 
          self.success = iprot.readI64();
5616 
        else:
5617 
          iprot.skip(ftype)
5618 
      elif fid == 1:
94 ashish 5619 
        if ftype == TType.STRUCT:
5620 
          self.ex = TransactionServiceException()
5621 
          self.ex.read(iprot)
5622 
        else:
5623 
          iprot.skip(ftype)
5624 
      else:
5625 
        iprot.skip(ftype)
5626 
      iprot.readFieldEnd()
5627 
    iprot.readStructEnd()
5628 
 
5629 
  def write(self, oprot):
5630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5632 
      return
5633 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5634 
    if self.success is not None:
132 ashish 5635 
      oprot.writeFieldBegin('success', TType.I64, 0)
5636 
      oprot.writeI64(self.success)
5637 
      oprot.writeFieldEnd()
3431 rajveer 5638 
    if self.ex is not None:
94 ashish 5639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5640 
      self.ex.write(oprot)
5641 
      oprot.writeFieldEnd()
5642 
    oprot.writeFieldStop()
5643 
    oprot.writeStructEnd()
5644 
 
3431 rajveer 5645 
  def validate(self):
5646 
    return
5647 
 
5648 
 
94 ashish 5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
5660 
class getTransaction_args:
5661 
  """
5662 
  Attributes:
5663 
   - id
5664 
  """
5665 
 
5666 
  thrift_spec = (
5667 
    None, # 0
5668 
    (1, TType.I64, 'id', None, None, ), # 1
5669 
  )
5670 
 
5671 
  def __init__(self, id=None,):
5672 
    self.id = id
5673 
 
5674 
  def read(self, iprot):
5675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5677 
      return
5678 
    iprot.readStructBegin()
5679 
    while True:
5680 
      (fname, ftype, fid) = iprot.readFieldBegin()
5681 
      if ftype == TType.STOP:
5682 
        break
5683 
      if fid == 1:
5684 
        if ftype == TType.I64:
5685 
          self.id = iprot.readI64();
5686 
        else:
5687 
          iprot.skip(ftype)
5688 
      else:
5689 
        iprot.skip(ftype)
5690 
      iprot.readFieldEnd()
5691 
    iprot.readStructEnd()
5692 
 
5693 
  def write(self, oprot):
5694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5696 
      return
5697 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5698 
    if self.id is not None:
94 ashish 5699 
      oprot.writeFieldBegin('id', TType.I64, 1)
5700 
      oprot.writeI64(self.id)
5701 
      oprot.writeFieldEnd()
5702 
    oprot.writeFieldStop()
5703 
    oprot.writeStructEnd()
5704 
 
3431 rajveer 5705 
  def validate(self):
5706 
    return
5707 
 
5708 
 
94 ashish 5709 
  def __repr__(self):
5710 
    L = ['%s=%r' % (key, value)
5711 
      for key, value in self.__dict__.iteritems()]
5712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5713 
 
5714 
  def __eq__(self, other):
5715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5716 
 
5717 
  def __ne__(self, other):
5718 
    return not (self == other)
5719 
 
5720 
class getTransaction_result:
5721 
  """
5722 
  Attributes:
5723 
   - success
5724 
   - ex
5725 
  """
5726 
 
5727 
  thrift_spec = (
5728 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5730 
  )
5731 
 
5732 
  def __init__(self, success=None, ex=None,):
5733 
    self.success = success
5734 
    self.ex = ex
5735 
 
5736 
  def read(self, iprot):
5737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5739 
      return
5740 
    iprot.readStructBegin()
5741 
    while True:
5742 
      (fname, ftype, fid) = iprot.readFieldBegin()
5743 
      if ftype == TType.STOP:
5744 
        break
5745 
      if fid == 0:
5746 
        if ftype == TType.STRUCT:
5747 
          self.success = Transaction()
5748 
          self.success.read(iprot)
5749 
        else:
5750 
          iprot.skip(ftype)
5751 
      elif fid == 1:
5752 
        if ftype == TType.STRUCT:
5753 
          self.ex = TransactionServiceException()
5754 
          self.ex.read(iprot)
5755 
        else:
5756 
          iprot.skip(ftype)
5757 
      else:
5758 
        iprot.skip(ftype)
5759 
      iprot.readFieldEnd()
5760 
    iprot.readStructEnd()
5761 
 
5762 
  def write(self, oprot):
5763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5765 
      return
5766 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5767 
    if self.success is not None:
94 ashish 5768 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5769 
      self.success.write(oprot)
5770 
      oprot.writeFieldEnd()
3431 rajveer 5771 
    if self.ex is not None:
94 ashish 5772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5773 
      self.ex.write(oprot)
5774 
      oprot.writeFieldEnd()
5775 
    oprot.writeFieldStop()
5776 
    oprot.writeStructEnd()
5777 
 
3431 rajveer 5778 
  def validate(self):
5779 
    return
5780 
 
5781 
 
94 ashish 5782 
  def __repr__(self):
5783 
    L = ['%s=%r' % (key, value)
5784 
      for key, value in self.__dict__.iteritems()]
5785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5786 
 
5787 
  def __eq__(self, other):
5788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5789 
 
5790 
  def __ne__(self, other):
5791 
    return not (self == other)
5792 
 
5793 
class getTransactionsForCustomer_args:
5794 
  """
5795 
  Attributes:
5796 
   - customerId
5797 
   - from_date
5798 
   - to_date
5799 
   - status
5800 
  """
5801 
 
5802 
  thrift_spec = (
5803 
    None, # 0
5804 
    (1, TType.I64, 'customerId', None, None, ), # 1
5805 
    (2, TType.I64, 'from_date', None, None, ), # 2
5806 
    (3, TType.I64, 'to_date', None, None, ), # 3
5807 
    (4, TType.I32, 'status', None, None, ), # 4
5808 
  )
5809 
 
5810 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5811 
    self.customerId = customerId
5812 
    self.from_date = from_date
5813 
    self.to_date = to_date
5814 
    self.status = status
5815 
 
5816 
  def read(self, iprot):
5817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5819 
      return
5820 
    iprot.readStructBegin()
5821 
    while True:
5822 
      (fname, ftype, fid) = iprot.readFieldBegin()
5823 
      if ftype == TType.STOP:
5824 
        break
5825 
      if fid == 1:
5826 
        if ftype == TType.I64:
5827 
          self.customerId = iprot.readI64();
5828 
        else:
5829 
          iprot.skip(ftype)
5830 
      elif fid == 2:
5831 
        if ftype == TType.I64:
5832 
          self.from_date = iprot.readI64();
5833 
        else:
5834 
          iprot.skip(ftype)
5835 
      elif fid == 3:
5836 
        if ftype == TType.I64:
5837 
          self.to_date = iprot.readI64();
5838 
        else:
5839 
          iprot.skip(ftype)
5840 
      elif fid == 4:
5841 
        if ftype == TType.I32:
5842 
          self.status = iprot.readI32();
5843 
        else:
5844 
          iprot.skip(ftype)
5845 
      else:
5846 
        iprot.skip(ftype)
5847 
      iprot.readFieldEnd()
5848 
    iprot.readStructEnd()
5849 
 
5850 
  def write(self, oprot):
5851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5853 
      return
5854 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5855 
    if self.customerId is not None:
94 ashish 5856 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5857 
      oprot.writeI64(self.customerId)
5858 
      oprot.writeFieldEnd()
3431 rajveer 5859 
    if self.from_date is not None:
94 ashish 5860 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5861 
      oprot.writeI64(self.from_date)
5862 
      oprot.writeFieldEnd()
3431 rajveer 5863 
    if self.to_date is not None:
94 ashish 5864 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5865 
      oprot.writeI64(self.to_date)
5866 
      oprot.writeFieldEnd()
3431 rajveer 5867 
    if self.status is not None:
94 ashish 5868 
      oprot.writeFieldBegin('status', TType.I32, 4)
5869 
      oprot.writeI32(self.status)
5870 
      oprot.writeFieldEnd()
5871 
    oprot.writeFieldStop()
5872 
    oprot.writeStructEnd()
5873 
 
3431 rajveer 5874 
  def validate(self):
5875 
    return
5876 
 
5877 
 
94 ashish 5878 
  def __repr__(self):
5879 
    L = ['%s=%r' % (key, value)
5880 
      for key, value in self.__dict__.iteritems()]
5881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5882 
 
5883 
  def __eq__(self, other):
5884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5885 
 
5886 
  def __ne__(self, other):
5887 
    return not (self == other)
5888 
 
5889 
class getTransactionsForCustomer_result:
5890 
  """
5891 
  Attributes:
5892 
   - success
5893 
   - ex
5894 
  """
5895 
 
5896 
  thrift_spec = (
5897 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5899 
  )
5900 
 
5901 
  def __init__(self, success=None, ex=None,):
5902 
    self.success = success
5903 
    self.ex = ex
5904 
 
5905 
  def read(self, iprot):
5906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5908 
      return
5909 
    iprot.readStructBegin()
5910 
    while True:
5911 
      (fname, ftype, fid) = iprot.readFieldBegin()
5912 
      if ftype == TType.STOP:
5913 
        break
5914 
      if fid == 0:
5915 
        if ftype == TType.LIST:
5916 
          self.success = []
685 chandransh 5917 
          (_etype17, _size14) = iprot.readListBegin()
5918 
          for _i18 in xrange(_size14):
5919 
            _elem19 = Transaction()
5920 
            _elem19.read(iprot)
5921 
            self.success.append(_elem19)
94 ashish 5922 
          iprot.readListEnd()
5923 
        else:
5924 
          iprot.skip(ftype)
5925 
      elif fid == 1:
5926 
        if ftype == TType.STRUCT:
5927 
          self.ex = TransactionServiceException()
5928 
          self.ex.read(iprot)
5929 
        else:
5930 
          iprot.skip(ftype)
5931 
      else:
5932 
        iprot.skip(ftype)
5933 
      iprot.readFieldEnd()
5934 
    iprot.readStructEnd()
5935 
 
5936 
  def write(self, oprot):
5937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5939 
      return
5940 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5941 
    if self.success is not None:
94 ashish 5942 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5943 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5944 
      for iter20 in self.success:
5945 
        iter20.write(oprot)
94 ashish 5946 
      oprot.writeListEnd()
5947 
      oprot.writeFieldEnd()
3431 rajveer 5948 
    if self.ex is not None:
94 ashish 5949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5950 
      self.ex.write(oprot)
5951 
      oprot.writeFieldEnd()
5952 
    oprot.writeFieldStop()
5953 
    oprot.writeStructEnd()
5954 
 
3431 rajveer 5955 
  def validate(self):
5956 
    return
5957 
 
5958 
 
94 ashish 5959 
  def __repr__(self):
5960 
    L = ['%s=%r' % (key, value)
5961 
      for key, value in self.__dict__.iteritems()]
5962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5963 
 
5964 
  def __eq__(self, other):
5965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5966 
 
5967 
  def __ne__(self, other):
5968 
    return not (self == other)
5969 
 
132 ashish 5970 
class getTransactionsForShoppingCartId_args:
5971 
  """
5972 
  Attributes:
5973 
   - shoppingCartId
5974 
  """
5975 
 
5976 
  thrift_spec = (
5977 
    None, # 0
5978 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5979 
  )
5980 
 
5981 
  def __init__(self, shoppingCartId=None,):
5982 
    self.shoppingCartId = shoppingCartId
5983 
 
5984 
  def read(self, iprot):
5985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5987 
      return
5988 
    iprot.readStructBegin()
5989 
    while True:
5990 
      (fname, ftype, fid) = iprot.readFieldBegin()
5991 
      if ftype == TType.STOP:
5992 
        break
5993 
      if fid == 1:
5994 
        if ftype == TType.I64:
5995 
          self.shoppingCartId = iprot.readI64();
5996 
        else:
5997 
          iprot.skip(ftype)
5998 
      else:
5999 
        iprot.skip(ftype)
6000 
      iprot.readFieldEnd()
6001 
    iprot.readStructEnd()
6002 
 
6003 
  def write(self, oprot):
6004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6006 
      return
6007 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6008 
    if self.shoppingCartId is not None:
132 ashish 6009 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6010 
      oprot.writeI64(self.shoppingCartId)
6011 
      oprot.writeFieldEnd()
6012 
    oprot.writeFieldStop()
6013 
    oprot.writeStructEnd()
6014 
 
3431 rajveer 6015 
  def validate(self):
6016 
    return
6017 
 
6018 
 
132 ashish 6019 
  def __repr__(self):
6020 
    L = ['%s=%r' % (key, value)
6021 
      for key, value in self.__dict__.iteritems()]
6022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6023 
 
6024 
  def __eq__(self, other):
6025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6026 
 
6027 
  def __ne__(self, other):
6028 
    return not (self == other)
6029 
 
6030 
class getTransactionsForShoppingCartId_result:
6031 
  """
6032 
  Attributes:
6033 
   - success
6034 
   - ex
6035 
  """
6036 
 
6037 
  thrift_spec = (
6038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6040 
  )
6041 
 
6042 
  def __init__(self, success=None, ex=None,):
6043 
    self.success = success
6044 
    self.ex = ex
6045 
 
6046 
  def read(self, iprot):
6047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6049 
      return
6050 
    iprot.readStructBegin()
6051 
    while True:
6052 
      (fname, ftype, fid) = iprot.readFieldBegin()
6053 
      if ftype == TType.STOP:
6054 
        break
6055 
      if fid == 0:
6056 
        if ftype == TType.LIST:
6057 
          self.success = []
685 chandransh 6058 
          (_etype24, _size21) = iprot.readListBegin()
6059 
          for _i25 in xrange(_size21):
6060 
            _elem26 = Transaction()
6061 
            _elem26.read(iprot)
6062 
            self.success.append(_elem26)
132 ashish 6063 
          iprot.readListEnd()
6064 
        else:
6065 
          iprot.skip(ftype)
6066 
      elif fid == 1:
6067 
        if ftype == TType.STRUCT:
6068 
          self.ex = TransactionServiceException()
6069 
          self.ex.read(iprot)
6070 
        else:
6071 
          iprot.skip(ftype)
6072 
      else:
6073 
        iprot.skip(ftype)
6074 
      iprot.readFieldEnd()
6075 
    iprot.readStructEnd()
6076 
 
6077 
  def write(self, oprot):
6078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6080 
      return
6081 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6082 
    if self.success is not None:
132 ashish 6083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6085 
      for iter27 in self.success:
6086 
        iter27.write(oprot)
132 ashish 6087 
      oprot.writeListEnd()
6088 
      oprot.writeFieldEnd()
3431 rajveer 6089 
    if self.ex is not None:
132 ashish 6090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6091 
      self.ex.write(oprot)
6092 
      oprot.writeFieldEnd()
6093 
    oprot.writeFieldStop()
6094 
    oprot.writeStructEnd()
6095 
 
3431 rajveer 6096 
  def validate(self):
6097 
    return
6098 
 
6099 
 
132 ashish 6100 
  def __repr__(self):
6101 
    L = ['%s=%r' % (key, value)
6102 
      for key, value in self.__dict__.iteritems()]
6103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6104 
 
6105 
  def __eq__(self, other):
6106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6107 
 
6108 
  def __ne__(self, other):
6109 
    return not (self == other)
6110 
 
94 ashish 6111 
class getTransactionStatus_args:
6112 
  """
6113 
  Attributes:
6114 
   - transactionId
6115 
  """
6116 
 
6117 
  thrift_spec = (
6118 
    None, # 0
6119 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6120 
  )
6121 
 
6122 
  def __init__(self, transactionId=None,):
6123 
    self.transactionId = transactionId
6124 
 
6125 
  def read(self, iprot):
6126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6128 
      return
6129 
    iprot.readStructBegin()
6130 
    while True:
6131 
      (fname, ftype, fid) = iprot.readFieldBegin()
6132 
      if ftype == TType.STOP:
6133 
        break
6134 
      if fid == 1:
6135 
        if ftype == TType.I64:
6136 
          self.transactionId = iprot.readI64();
6137 
        else:
6138 
          iprot.skip(ftype)
6139 
      else:
6140 
        iprot.skip(ftype)
6141 
      iprot.readFieldEnd()
6142 
    iprot.readStructEnd()
6143 
 
6144 
  def write(self, oprot):
6145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6147 
      return
6148 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6149 
    if self.transactionId is not None:
94 ashish 6150 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6151 
      oprot.writeI64(self.transactionId)
6152 
      oprot.writeFieldEnd()
6153 
    oprot.writeFieldStop()
6154 
    oprot.writeStructEnd()
6155 
 
3431 rajveer 6156 
  def validate(self):
6157 
    return
6158 
 
6159 
 
94 ashish 6160 
  def __repr__(self):
6161 
    L = ['%s=%r' % (key, value)
6162 
      for key, value in self.__dict__.iteritems()]
6163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6164 
 
6165 
  def __eq__(self, other):
6166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6167 
 
6168 
  def __ne__(self, other):
6169 
    return not (self == other)
6170 
 
6171 
class getTransactionStatus_result:
6172 
  """
6173 
  Attributes:
6174 
   - success
6175 
   - ex
6176 
  """
6177 
 
6178 
  thrift_spec = (
6179 
    (0, TType.I32, 'success', None, None, ), # 0
6180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6181 
  )
6182 
 
6183 
  def __init__(self, success=None, ex=None,):
6184 
    self.success = success
6185 
    self.ex = ex
6186 
 
6187 
  def read(self, iprot):
6188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6190 
      return
6191 
    iprot.readStructBegin()
6192 
    while True:
6193 
      (fname, ftype, fid) = iprot.readFieldBegin()
6194 
      if ftype == TType.STOP:
6195 
        break
6196 
      if fid == 0:
6197 
        if ftype == TType.I32:
6198 
          self.success = iprot.readI32();
6199 
        else:
6200 
          iprot.skip(ftype)
6201 
      elif fid == 1:
6202 
        if ftype == TType.STRUCT:
6203 
          self.ex = TransactionServiceException()
6204 
          self.ex.read(iprot)
6205 
        else:
6206 
          iprot.skip(ftype)
6207 
      else:
6208 
        iprot.skip(ftype)
6209 
      iprot.readFieldEnd()
6210 
    iprot.readStructEnd()
6211 
 
6212 
  def write(self, oprot):
6213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6215 
      return
6216 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6217 
    if self.success is not None:
94 ashish 6218 
      oprot.writeFieldBegin('success', TType.I32, 0)
6219 
      oprot.writeI32(self.success)
6220 
      oprot.writeFieldEnd()
3431 rajveer 6221 
    if self.ex is not None:
94 ashish 6222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6223 
      self.ex.write(oprot)
6224 
      oprot.writeFieldEnd()
6225 
    oprot.writeFieldStop()
6226 
    oprot.writeStructEnd()
6227 
 
3431 rajveer 6228 
  def validate(self):
6229 
    return
6230 
 
6231 
 
94 ashish 6232 
  def __repr__(self):
6233 
    L = ['%s=%r' % (key, value)
6234 
      for key, value in self.__dict__.iteritems()]
6235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6236 
 
6237 
  def __eq__(self, other):
6238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6239 
 
6240 
  def __ne__(self, other):
6241 
    return not (self == other)
6242 
 
6243 
class changeTransactionStatus_args:
6244 
  """
6245 
  Attributes:
6246 
   - transactionId
6247 
   - status
6248 
   - description
6249 
  """
6250 
 
6251 
  thrift_spec = (
6252 
    None, # 0
6253 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6254 
    (2, TType.I32, 'status', None, None, ), # 2
6255 
    (3, TType.STRING, 'description', None, None, ), # 3
6256 
  )
6257 
 
6258 
  def __init__(self, transactionId=None, status=None, description=None,):
6259 
    self.transactionId = transactionId
6260 
    self.status = status
6261 
    self.description = description
6262 
 
6263 
  def read(self, iprot):
6264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6266 
      return
6267 
    iprot.readStructBegin()
6268 
    while True:
6269 
      (fname, ftype, fid) = iprot.readFieldBegin()
6270 
      if ftype == TType.STOP:
6271 
        break
6272 
      if fid == 1:
6273 
        if ftype == TType.I64:
6274 
          self.transactionId = iprot.readI64();
6275 
        else:
6276 
          iprot.skip(ftype)
6277 
      elif fid == 2:
6278 
        if ftype == TType.I32:
6279 
          self.status = iprot.readI32();
6280 
        else:
6281 
          iprot.skip(ftype)
6282 
      elif fid == 3:
6283 
        if ftype == TType.STRING:
6284 
          self.description = iprot.readString();
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      else:
6288 
        iprot.skip(ftype)
6289 
      iprot.readFieldEnd()
6290 
    iprot.readStructEnd()
6291 
 
6292 
  def write(self, oprot):
6293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6295 
      return
6296 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6297 
    if self.transactionId is not None:
94 ashish 6298 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6299 
      oprot.writeI64(self.transactionId)
6300 
      oprot.writeFieldEnd()
3431 rajveer 6301 
    if self.status is not None:
94 ashish 6302 
      oprot.writeFieldBegin('status', TType.I32, 2)
6303 
      oprot.writeI32(self.status)
6304 
      oprot.writeFieldEnd()
3431 rajveer 6305 
    if self.description is not None:
94 ashish 6306 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6307 
      oprot.writeString(self.description)
6308 
      oprot.writeFieldEnd()
6309 
    oprot.writeFieldStop()
6310 
    oprot.writeStructEnd()
6311 
 
3431 rajveer 6312 
  def validate(self):
6313 
    return
6314 
 
6315 
 
94 ashish 6316 
  def __repr__(self):
6317 
    L = ['%s=%r' % (key, value)
6318 
      for key, value in self.__dict__.iteritems()]
6319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6320 
 
6321 
  def __eq__(self, other):
6322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6323 
 
6324 
  def __ne__(self, other):
6325 
    return not (self == other)
6326 
 
6327 
class changeTransactionStatus_result:
6328 
  """
6329 
  Attributes:
6330 
   - success
6331 
   - ex
6332 
  """
6333 
 
6334 
  thrift_spec = (
6335 
    (0, TType.BOOL, 'success', None, None, ), # 0
6336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6337 
  )
6338 
 
6339 
  def __init__(self, success=None, ex=None,):
6340 
    self.success = success
6341 
    self.ex = ex
6342 
 
6343 
  def read(self, iprot):
6344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6346 
      return
6347 
    iprot.readStructBegin()
6348 
    while True:
6349 
      (fname, ftype, fid) = iprot.readFieldBegin()
6350 
      if ftype == TType.STOP:
6351 
        break
6352 
      if fid == 0:
6353 
        if ftype == TType.BOOL:
6354 
          self.success = iprot.readBool();
6355 
        else:
6356 
          iprot.skip(ftype)
6357 
      elif fid == 1:
6358 
        if ftype == TType.STRUCT:
6359 
          self.ex = TransactionServiceException()
6360 
          self.ex.read(iprot)
6361 
        else:
6362 
          iprot.skip(ftype)
6363 
      else:
6364 
        iprot.skip(ftype)
6365 
      iprot.readFieldEnd()
6366 
    iprot.readStructEnd()
6367 
 
6368 
  def write(self, oprot):
6369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6371 
      return
6372 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6373 
    if self.success is not None:
94 ashish 6374 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6375 
      oprot.writeBool(self.success)
6376 
      oprot.writeFieldEnd()
3431 rajveer 6377 
    if self.ex is not None:
94 ashish 6378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6379 
      self.ex.write(oprot)
6380 
      oprot.writeFieldEnd()
6381 
    oprot.writeFieldStop()
6382 
    oprot.writeStructEnd()
6383 
 
3431 rajveer 6384 
  def validate(self):
6385 
    return
6386 
 
6387 
 
94 ashish 6388 
  def __repr__(self):
6389 
    L = ['%s=%r' % (key, value)
6390 
      for key, value in self.__dict__.iteritems()]
6391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6392 
 
6393 
  def __eq__(self, other):
6394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6395 
 
6396 
  def __ne__(self, other):
6397 
    return not (self == other)
6398 
 
1398 varun.gupt 6399 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6400 
  """
6401 
  Attributes:
6402 
   - transactionId
6403 
  """
6404 
 
6405 
  thrift_spec = (
6406 
    None, # 0
6407 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6408 
  )
6409 
 
6410 
  def __init__(self, transactionId=None,):
6411 
    self.transactionId = transactionId
6412 
 
6413 
  def read(self, iprot):
6414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6416 
      return
6417 
    iprot.readStructBegin()
6418 
    while True:
6419 
      (fname, ftype, fid) = iprot.readFieldBegin()
6420 
      if ftype == TType.STOP:
6421 
        break
6422 
      if fid == 1:
6423 
        if ftype == TType.I64:
6424 
          self.transactionId = iprot.readI64();
6425 
        else:
6426 
          iprot.skip(ftype)
6427 
      else:
6428 
        iprot.skip(ftype)
6429 
      iprot.readFieldEnd()
6430 
    iprot.readStructEnd()
6431 
 
6432 
  def write(self, oprot):
6433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6435 
      return
1398 varun.gupt 6436 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6437 
    if self.transactionId is not None:
1382 varun.gupt 6438 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6439 
      oprot.writeI64(self.transactionId)
6440 
      oprot.writeFieldEnd()
6441 
    oprot.writeFieldStop()
6442 
    oprot.writeStructEnd()
6443 
 
3431 rajveer 6444 
  def validate(self):
6445 
    return
6446 
 
6447 
 
1382 varun.gupt 6448 
  def __repr__(self):
6449 
    L = ['%s=%r' % (key, value)
6450 
      for key, value in self.__dict__.iteritems()]
6451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6452 
 
6453 
  def __eq__(self, other):
6454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6455 
 
6456 
  def __ne__(self, other):
6457 
    return not (self == other)
6458 
 
1398 varun.gupt 6459 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6460 
  """
6461 
  Attributes:
6462 
   - success
6463 
   - ex
6464 
  """
6465 
 
6466 
  thrift_spec = (
6467 
    (0, TType.BOOL, 'success', None, None, ), # 0
6468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6469 
  )
6470 
 
6471 
  def __init__(self, success=None, ex=None,):
6472 
    self.success = success
6473 
    self.ex = ex
6474 
 
6475 
  def read(self, iprot):
6476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6478 
      return
6479 
    iprot.readStructBegin()
6480 
    while True:
6481 
      (fname, ftype, fid) = iprot.readFieldBegin()
6482 
      if ftype == TType.STOP:
6483 
        break
6484 
      if fid == 0:
6485 
        if ftype == TType.BOOL:
6486 
          self.success = iprot.readBool();
6487 
        else:
6488 
          iprot.skip(ftype)
6489 
      elif fid == 1:
6490 
        if ftype == TType.STRUCT:
6491 
          self.ex = TransactionServiceException()
6492 
          self.ex.read(iprot)
6493 
        else:
6494 
          iprot.skip(ftype)
6495 
      else:
6496 
        iprot.skip(ftype)
6497 
      iprot.readFieldEnd()
6498 
    iprot.readStructEnd()
6499 
 
6500 
  def write(self, oprot):
6501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6503 
      return
1398 varun.gupt 6504 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6505 
    if self.success is not None:
1382 varun.gupt 6506 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6507 
      oprot.writeBool(self.success)
6508 
      oprot.writeFieldEnd()
3431 rajveer 6509 
    if self.ex is not None:
1382 varun.gupt 6510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6511 
      self.ex.write(oprot)
6512 
      oprot.writeFieldEnd()
6513 
    oprot.writeFieldStop()
6514 
    oprot.writeStructEnd()
6515 
 
3431 rajveer 6516 
  def validate(self):
6517 
    return
6518 
 
6519 
 
1382 varun.gupt 6520 
  def __repr__(self):
6521 
    L = ['%s=%r' % (key, value)
6522 
      for key, value in self.__dict__.iteritems()]
6523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6524 
 
6525 
  def __eq__(self, other):
6526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6527 
 
6528 
  def __ne__(self, other):
6529 
    return not (self == other)
6530 
 
483 rajveer 6531 
class getAllOrders_args:
94 ashish 6532 
  """
6533 
  Attributes:
483 rajveer 6534 
   - status
6535 
   - from_date
6536 
   - to_date
6537 
   - warehouse_id
94 ashish 6538 
  """
6539 
 
6540 
  thrift_spec = (
6541 
    None, # 0
483 rajveer 6542 
    (1, TType.I32, 'status', None, None, ), # 1
6543 
    (2, TType.I64, 'from_date', None, None, ), # 2
6544 
    (3, TType.I64, 'to_date', None, None, ), # 3
6545 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6546 
  )
6547 
 
483 rajveer 6548 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6549 
    self.status = status
6550 
    self.from_date = from_date
6551 
    self.to_date = to_date
6552 
    self.warehouse_id = warehouse_id
94 ashish 6553 
 
6554 
  def read(self, iprot):
6555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6557 
      return
6558 
    iprot.readStructBegin()
6559 
    while True:
6560 
      (fname, ftype, fid) = iprot.readFieldBegin()
6561 
      if ftype == TType.STOP:
6562 
        break
6563 
      if fid == 1:
483 rajveer 6564 
        if ftype == TType.I32:
6565 
          self.status = iprot.readI32();
94 ashish 6566 
        else:
6567 
          iprot.skip(ftype)
483 rajveer 6568 
      elif fid == 2:
6569 
        if ftype == TType.I64:
6570 
          self.from_date = iprot.readI64();
94 ashish 6571 
        else:
6572 
          iprot.skip(ftype)
483 rajveer 6573 
      elif fid == 3:
6574 
        if ftype == TType.I64:
6575 
          self.to_date = iprot.readI64();
94 ashish 6576 
        else:
6577 
          iprot.skip(ftype)
483 rajveer 6578 
      elif fid == 4:
94 ashish 6579 
        if ftype == TType.I64:
483 rajveer 6580 
          self.warehouse_id = iprot.readI64();
94 ashish 6581 
        else:
6582 
          iprot.skip(ftype)
6583 
      else:
6584 
        iprot.skip(ftype)
6585 
      iprot.readFieldEnd()
6586 
    iprot.readStructEnd()
6587 
 
6588 
  def write(self, oprot):
6589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6591 
      return
483 rajveer 6592 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6593 
    if self.status is not None:
483 rajveer 6594 
      oprot.writeFieldBegin('status', TType.I32, 1)
6595 
      oprot.writeI32(self.status)
94 ashish 6596 
      oprot.writeFieldEnd()
3431 rajveer 6597 
    if self.from_date is not None:
483 rajveer 6598 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6599 
      oprot.writeI64(self.from_date)
94 ashish 6600 
      oprot.writeFieldEnd()
3431 rajveer 6601 
    if self.to_date is not None:
483 rajveer 6602 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6603 
      oprot.writeI64(self.to_date)
94 ashish 6604 
      oprot.writeFieldEnd()
3431 rajveer 6605 
    if self.warehouse_id is not None:
483 rajveer 6606 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6607 
      oprot.writeI64(self.warehouse_id)
94 ashish 6608 
      oprot.writeFieldEnd()
6609 
    oprot.writeFieldStop()
6610 
    oprot.writeStructEnd()
6611 
 
3431 rajveer 6612 
  def validate(self):
6613 
    return
6614 
 
6615 
 
94 ashish 6616 
  def __repr__(self):
6617 
    L = ['%s=%r' % (key, value)
6618 
      for key, value in self.__dict__.iteritems()]
6619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6620 
 
6621 
  def __eq__(self, other):
6622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6623 
 
6624 
  def __ne__(self, other):
6625 
    return not (self == other)
6626 
 
483 rajveer 6627 
class getAllOrders_result:
94 ashish 6628 
  """
6629 
  Attributes:
6630 
   - success
6631 
   - ex
6632 
  """
6633 
 
6634 
  thrift_spec = (
483 rajveer 6635 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6637 
  )
6638 
 
6639 
  def __init__(self, success=None, ex=None,):
6640 
    self.success = success
6641 
    self.ex = ex
6642 
 
6643 
  def read(self, iprot):
6644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6646 
      return
6647 
    iprot.readStructBegin()
6648 
    while True:
6649 
      (fname, ftype, fid) = iprot.readFieldBegin()
6650 
      if ftype == TType.STOP:
6651 
        break
6652 
      if fid == 0:
483 rajveer 6653 
        if ftype == TType.LIST:
6654 
          self.success = []
685 chandransh 6655 
          (_etype31, _size28) = iprot.readListBegin()
6656 
          for _i32 in xrange(_size28):
6657 
            _elem33 = Order()
6658 
            _elem33.read(iprot)
6659 
            self.success.append(_elem33)
483 rajveer 6660 
          iprot.readListEnd()
94 ashish 6661 
        else:
6662 
          iprot.skip(ftype)
6663 
      elif fid == 1:
6664 
        if ftype == TType.STRUCT:
6665 
          self.ex = TransactionServiceException()
6666 
          self.ex.read(iprot)
6667 
        else:
6668 
          iprot.skip(ftype)
6669 
      else:
6670 
        iprot.skip(ftype)
6671 
      iprot.readFieldEnd()
6672 
    iprot.readStructEnd()
6673 
 
6674 
  def write(self, oprot):
6675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6677 
      return
483 rajveer 6678 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6679 
    if self.success is not None:
483 rajveer 6680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6681 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6682 
      for iter34 in self.success:
6683 
        iter34.write(oprot)
483 rajveer 6684 
      oprot.writeListEnd()
94 ashish 6685 
      oprot.writeFieldEnd()
3431 rajveer 6686 
    if self.ex is not None:
94 ashish 6687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6688 
      self.ex.write(oprot)
6689 
      oprot.writeFieldEnd()
6690 
    oprot.writeFieldStop()
6691 
    oprot.writeStructEnd()
6692 
 
3431 rajveer 6693 
  def validate(self):
6694 
    return
6695 
 
6696 
 
94 ashish 6697 
  def __repr__(self):
6698 
    L = ['%s=%r' % (key, value)
6699 
      for key, value in self.__dict__.iteritems()]
6700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6701 
 
6702 
  def __eq__(self, other):
6703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6704 
 
6705 
  def __ne__(self, other):
6706 
    return not (self == other)
6707 
 
4133 chandransh 6708 
class getOrdersInBatch_args:
6709 
  """
6710 
  Attributes:
6711 
   - statuses
6712 
   - offset
6713 
   - limit
6714 
   - warehouse_id
6715 
  """
6716 
 
6717 
  thrift_spec = (
6718 
    None, # 0
6719 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6720 
    (2, TType.I64, 'offset', None, None, ), # 2
6721 
    (3, TType.I64, 'limit', None, None, ), # 3
6722 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6723 
  )
6724 
 
6725 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6726 
    self.statuses = statuses
6727 
    self.offset = offset
6728 
    self.limit = limit
6729 
    self.warehouse_id = warehouse_id
6730 
 
6731 
  def read(self, iprot):
6732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6734 
      return
6735 
    iprot.readStructBegin()
6736 
    while True:
6737 
      (fname, ftype, fid) = iprot.readFieldBegin()
6738 
      if ftype == TType.STOP:
6739 
        break
6740 
      if fid == 1:
6741 
        if ftype == TType.LIST:
6742 
          self.statuses = []
6743 
          (_etype38, _size35) = iprot.readListBegin()
6744 
          for _i39 in xrange(_size35):
6745 
            _elem40 = iprot.readI32();
6746 
            self.statuses.append(_elem40)
6747 
          iprot.readListEnd()
6748 
        else:
6749 
          iprot.skip(ftype)
6750 
      elif fid == 2:
6751 
        if ftype == TType.I64:
6752 
          self.offset = iprot.readI64();
6753 
        else:
6754 
          iprot.skip(ftype)
6755 
      elif fid == 3:
6756 
        if ftype == TType.I64:
6757 
          self.limit = iprot.readI64();
6758 
        else:
6759 
          iprot.skip(ftype)
6760 
      elif fid == 4:
6761 
        if ftype == TType.I64:
6762 
          self.warehouse_id = iprot.readI64();
6763 
        else:
6764 
          iprot.skip(ftype)
6765 
      else:
6766 
        iprot.skip(ftype)
6767 
      iprot.readFieldEnd()
6768 
    iprot.readStructEnd()
6769 
 
6770 
  def write(self, oprot):
6771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6773 
      return
6774 
    oprot.writeStructBegin('getOrdersInBatch_args')
6775 
    if self.statuses is not None:
6776 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6777 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6778 
      for iter41 in self.statuses:
6779 
        oprot.writeI32(iter41)
6780 
      oprot.writeListEnd()
6781 
      oprot.writeFieldEnd()
6782 
    if self.offset is not None:
6783 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6784 
      oprot.writeI64(self.offset)
6785 
      oprot.writeFieldEnd()
6786 
    if self.limit is not None:
6787 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6788 
      oprot.writeI64(self.limit)
6789 
      oprot.writeFieldEnd()
6790 
    if self.warehouse_id is not None:
6791 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6792 
      oprot.writeI64(self.warehouse_id)
6793 
      oprot.writeFieldEnd()
6794 
    oprot.writeFieldStop()
6795 
    oprot.writeStructEnd()
6796 
 
6797 
  def validate(self):
6798 
    return
6799 
 
6800 
 
6801 
  def __repr__(self):
6802 
    L = ['%s=%r' % (key, value)
6803 
      for key, value in self.__dict__.iteritems()]
6804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6805 
 
6806 
  def __eq__(self, other):
6807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6808 
 
6809 
  def __ne__(self, other):
6810 
    return not (self == other)
6811 
 
6812 
class getOrdersInBatch_result:
6813 
  """
6814 
  Attributes:
6815 
   - success
6816 
   - ex
6817 
  """
6818 
 
6819 
  thrift_spec = (
6820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6822 
  )
6823 
 
6824 
  def __init__(self, success=None, ex=None,):
6825 
    self.success = success
6826 
    self.ex = ex
6827 
 
6828 
  def read(self, iprot):
6829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6831 
      return
6832 
    iprot.readStructBegin()
6833 
    while True:
6834 
      (fname, ftype, fid) = iprot.readFieldBegin()
6835 
      if ftype == TType.STOP:
6836 
        break
6837 
      if fid == 0:
6838 
        if ftype == TType.LIST:
6839 
          self.success = []
6840 
          (_etype45, _size42) = iprot.readListBegin()
6841 
          for _i46 in xrange(_size42):
6842 
            _elem47 = Order()
6843 
            _elem47.read(iprot)
6844 
            self.success.append(_elem47)
6845 
          iprot.readListEnd()
6846 
        else:
6847 
          iprot.skip(ftype)
6848 
      elif fid == 1:
6849 
        if ftype == TType.STRUCT:
6850 
          self.ex = TransactionServiceException()
6851 
          self.ex.read(iprot)
6852 
        else:
6853 
          iprot.skip(ftype)
6854 
      else:
6855 
        iprot.skip(ftype)
6856 
      iprot.readFieldEnd()
6857 
    iprot.readStructEnd()
6858 
 
6859 
  def write(self, oprot):
6860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6862 
      return
6863 
    oprot.writeStructBegin('getOrdersInBatch_result')
6864 
    if self.success is not None:
6865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6867 
      for iter48 in self.success:
6868 
        iter48.write(oprot)
6869 
      oprot.writeListEnd()
6870 
      oprot.writeFieldEnd()
6871 
    if self.ex is not None:
6872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6873 
      self.ex.write(oprot)
6874 
      oprot.writeFieldEnd()
6875 
    oprot.writeFieldStop()
6876 
    oprot.writeStructEnd()
6877 
 
6878 
  def validate(self):
6879 
    return
6880 
 
6881 
 
6882 
  def __repr__(self):
6883 
    L = ['%s=%r' % (key, value)
6884 
      for key, value in self.__dict__.iteritems()]
6885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6886 
 
6887 
  def __eq__(self, other):
6888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6889 
 
6890 
  def __ne__(self, other):
6891 
    return not (self == other)
6892 
 
6893 
class getOrderCount_args:
6894 
  """
6895 
  Attributes:
6896 
   - statuses
6897 
   - warehouseId
6898 
  """
6899 
 
6900 
  thrift_spec = (
6901 
    None, # 0
6902 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6903 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6904 
  )
6905 
 
6906 
  def __init__(self, statuses=None, warehouseId=None,):
6907 
    self.statuses = statuses
6908 
    self.warehouseId = warehouseId
6909 
 
6910 
  def read(self, iprot):
6911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6913 
      return
6914 
    iprot.readStructBegin()
6915 
    while True:
6916 
      (fname, ftype, fid) = iprot.readFieldBegin()
6917 
      if ftype == TType.STOP:
6918 
        break
6919 
      if fid == 1:
6920 
        if ftype == TType.LIST:
6921 
          self.statuses = []
6922 
          (_etype52, _size49) = iprot.readListBegin()
6923 
          for _i53 in xrange(_size49):
6924 
            _elem54 = iprot.readI32();
6925 
            self.statuses.append(_elem54)
6926 
          iprot.readListEnd()
6927 
        else:
6928 
          iprot.skip(ftype)
6929 
      elif fid == 2:
6930 
        if ftype == TType.I64:
6931 
          self.warehouseId = iprot.readI64();
6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      else:
6935 
        iprot.skip(ftype)
6936 
      iprot.readFieldEnd()
6937 
    iprot.readStructEnd()
6938 
 
6939 
  def write(self, oprot):
6940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6942 
      return
6943 
    oprot.writeStructBegin('getOrderCount_args')
6944 
    if self.statuses is not None:
6945 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6946 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6947 
      for iter55 in self.statuses:
6948 
        oprot.writeI32(iter55)
6949 
      oprot.writeListEnd()
6950 
      oprot.writeFieldEnd()
6951 
    if self.warehouseId is not None:
6952 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6953 
      oprot.writeI64(self.warehouseId)
6954 
      oprot.writeFieldEnd()
6955 
    oprot.writeFieldStop()
6956 
    oprot.writeStructEnd()
6957 
 
6958 
  def validate(self):
6959 
    return
6960 
 
6961 
 
6962 
  def __repr__(self):
6963 
    L = ['%s=%r' % (key, value)
6964 
      for key, value in self.__dict__.iteritems()]
6965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6966 
 
6967 
  def __eq__(self, other):
6968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6969 
 
6970 
  def __ne__(self, other):
6971 
    return not (self == other)
6972 
 
6973 
class getOrderCount_result:
6974 
  """
6975 
  Attributes:
6976 
   - success
6977 
   - ex
6978 
  """
6979 
 
6980 
  thrift_spec = (
6981 
    (0, TType.I32, 'success', None, None, ), # 0
6982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6983 
  )
6984 
 
6985 
  def __init__(self, success=None, ex=None,):
6986 
    self.success = success
6987 
    self.ex = ex
6988 
 
6989 
  def read(self, iprot):
6990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6992 
      return
6993 
    iprot.readStructBegin()
6994 
    while True:
6995 
      (fname, ftype, fid) = iprot.readFieldBegin()
6996 
      if ftype == TType.STOP:
6997 
        break
6998 
      if fid == 0:
6999 
        if ftype == TType.I32:
7000 
          self.success = iprot.readI32();
7001 
        else:
7002 
          iprot.skip(ftype)
7003 
      elif fid == 1:
7004 
        if ftype == TType.STRUCT:
7005 
          self.ex = TransactionServiceException()
7006 
          self.ex.read(iprot)
7007 
        else:
7008 
          iprot.skip(ftype)
7009 
      else:
7010 
        iprot.skip(ftype)
7011 
      iprot.readFieldEnd()
7012 
    iprot.readStructEnd()
7013 
 
7014 
  def write(self, oprot):
7015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7017 
      return
7018 
    oprot.writeStructBegin('getOrderCount_result')
7019 
    if self.success is not None:
7020 
      oprot.writeFieldBegin('success', TType.I32, 0)
7021 
      oprot.writeI32(self.success)
7022 
      oprot.writeFieldEnd()
7023 
    if self.ex is not None:
7024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7025 
      self.ex.write(oprot)
7026 
      oprot.writeFieldEnd()
7027 
    oprot.writeFieldStop()
7028 
    oprot.writeStructEnd()
7029 
 
7030 
  def validate(self):
7031 
    return
7032 
 
7033 
 
7034 
  def __repr__(self):
7035 
    L = ['%s=%r' % (key, value)
7036 
      for key, value in self.__dict__.iteritems()]
7037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7038 
 
7039 
  def __eq__(self, other):
7040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7041 
 
7042 
  def __ne__(self, other):
7043 
    return not (self == other)
7044 
 
999 varun.gupt 7045 
class getOrdersByBillingDate_args:
7046 
  """
7047 
  Attributes:
7048 
   - status
7049 
   - start_billing_date
7050 
   - end_billing_date
7051 
   - warehouse_id
7052 
  """
7053 
 
7054 
  thrift_spec = (
7055 
    None, # 0
7056 
    (1, TType.I32, 'status', None, None, ), # 1
7057 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7058 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7059 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7060 
  )
7061 
 
7062 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7063 
    self.status = status
7064 
    self.start_billing_date = start_billing_date
7065 
    self.end_billing_date = end_billing_date
7066 
    self.warehouse_id = warehouse_id
7067 
 
7068 
  def read(self, iprot):
7069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7071 
      return
7072 
    iprot.readStructBegin()
7073 
    while True:
7074 
      (fname, ftype, fid) = iprot.readFieldBegin()
7075 
      if ftype == TType.STOP:
7076 
        break
7077 
      if fid == 1:
7078 
        if ftype == TType.I32:
7079 
          self.status = iprot.readI32();
7080 
        else:
7081 
          iprot.skip(ftype)
7082 
      elif fid == 2:
7083 
        if ftype == TType.I64:
7084 
          self.start_billing_date = iprot.readI64();
7085 
        else:
7086 
          iprot.skip(ftype)
7087 
      elif fid == 3:
7088 
        if ftype == TType.I64:
7089 
          self.end_billing_date = iprot.readI64();
7090 
        else:
7091 
          iprot.skip(ftype)
7092 
      elif fid == 4:
7093 
        if ftype == TType.I64:
7094 
          self.warehouse_id = iprot.readI64();
7095 
        else:
7096 
          iprot.skip(ftype)
7097 
      else:
7098 
        iprot.skip(ftype)
7099 
      iprot.readFieldEnd()
7100 
    iprot.readStructEnd()
7101 
 
7102 
  def write(self, oprot):
7103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7105 
      return
7106 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7107 
    if self.status is not None:
999 varun.gupt 7108 
      oprot.writeFieldBegin('status', TType.I32, 1)
7109 
      oprot.writeI32(self.status)
7110 
      oprot.writeFieldEnd()
3431 rajveer 7111 
    if self.start_billing_date is not None:
999 varun.gupt 7112 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7113 
      oprot.writeI64(self.start_billing_date)
7114 
      oprot.writeFieldEnd()
3431 rajveer 7115 
    if self.end_billing_date is not None:
999 varun.gupt 7116 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7117 
      oprot.writeI64(self.end_billing_date)
7118 
      oprot.writeFieldEnd()
3431 rajveer 7119 
    if self.warehouse_id is not None:
999 varun.gupt 7120 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7121 
      oprot.writeI64(self.warehouse_id)
7122 
      oprot.writeFieldEnd()
7123 
    oprot.writeFieldStop()
7124 
    oprot.writeStructEnd()
7125 
 
3431 rajveer 7126 
  def validate(self):
7127 
    return
7128 
 
7129 
 
999 varun.gupt 7130 
  def __repr__(self):
7131 
    L = ['%s=%r' % (key, value)
7132 
      for key, value in self.__dict__.iteritems()]
7133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7134 
 
7135 
  def __eq__(self, other):
7136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7137 
 
7138 
  def __ne__(self, other):
7139 
    return not (self == other)
7140 
 
7141 
class getOrdersByBillingDate_result:
7142 
  """
7143 
  Attributes:
7144 
   - success
7145 
   - ex
7146 
  """
7147 
 
7148 
  thrift_spec = (
7149 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7151 
  )
7152 
 
7153 
  def __init__(self, success=None, ex=None,):
7154 
    self.success = success
7155 
    self.ex = ex
7156 
 
7157 
  def read(self, iprot):
7158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7160 
      return
7161 
    iprot.readStructBegin()
7162 
    while True:
7163 
      (fname, ftype, fid) = iprot.readFieldBegin()
7164 
      if ftype == TType.STOP:
7165 
        break
7166 
      if fid == 0:
7167 
        if ftype == TType.LIST:
7168 
          self.success = []
4133 chandransh 7169 
          (_etype59, _size56) = iprot.readListBegin()
7170 
          for _i60 in xrange(_size56):
7171 
            _elem61 = Order()
7172 
            _elem61.read(iprot)
7173 
            self.success.append(_elem61)
999 varun.gupt 7174 
          iprot.readListEnd()
7175 
        else:
7176 
          iprot.skip(ftype)
7177 
      elif fid == 1:
7178 
        if ftype == TType.STRUCT:
7179 
          self.ex = TransactionServiceException()
7180 
          self.ex.read(iprot)
7181 
        else:
7182 
          iprot.skip(ftype)
7183 
      else:
7184 
        iprot.skip(ftype)
7185 
      iprot.readFieldEnd()
7186 
    iprot.readStructEnd()
7187 
 
7188 
  def write(self, oprot):
7189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7191 
      return
7192 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7193 
    if self.success is not None:
999 varun.gupt 7194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7196 
      for iter62 in self.success:
7197 
        iter62.write(oprot)
999 varun.gupt 7198 
      oprot.writeListEnd()
7199 
      oprot.writeFieldEnd()
3431 rajveer 7200 
    if self.ex is not None:
999 varun.gupt 7201 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7202 
      self.ex.write(oprot)
7203 
      oprot.writeFieldEnd()
7204 
    oprot.writeFieldStop()
7205 
    oprot.writeStructEnd()
7206 
 
3431 rajveer 7207 
  def validate(self):
7208 
    return
7209 
 
7210 
 
999 varun.gupt 7211 
  def __repr__(self):
7212 
    L = ['%s=%r' % (key, value)
7213 
      for key, value in self.__dict__.iteritems()]
7214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7215 
 
7216 
  def __eq__(self, other):
7217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7218 
 
7219 
  def __ne__(self, other):
7220 
    return not (self == other)
7221 
 
3427 chandransh 7222 
class getOrdersByShippingDate_args:
7223 
  """
7224 
  Attributes:
7225 
   - fromShippingDate
7226 
   - toShippingDate
7227 
   - providerId
7228 
   - warehouseId
3451 chandransh 7229 
   - cod
3427 chandransh 7230 
  """
7231 
 
7232 
  thrift_spec = (
7233 
    None, # 0
7234 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7235 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7236 
    (3, TType.I64, 'providerId', None, None, ), # 3
7237 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7238 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7239 
  )
7240 
 
3451 chandransh 7241 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7242 
    self.fromShippingDate = fromShippingDate
7243 
    self.toShippingDate = toShippingDate
7244 
    self.providerId = providerId
7245 
    self.warehouseId = warehouseId
3451 chandransh 7246 
    self.cod = cod
3427 chandransh 7247 
 
7248 
  def read(self, iprot):
7249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7251 
      return
7252 
    iprot.readStructBegin()
7253 
    while True:
7254 
      (fname, ftype, fid) = iprot.readFieldBegin()
7255 
      if ftype == TType.STOP:
7256 
        break
7257 
      if fid == 1:
7258 
        if ftype == TType.I64:
7259 
          self.fromShippingDate = iprot.readI64();
7260 
        else:
7261 
          iprot.skip(ftype)
7262 
      elif fid == 2:
7263 
        if ftype == TType.I64:
7264 
          self.toShippingDate = iprot.readI64();
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 3:
7268 
        if ftype == TType.I64:
7269 
          self.providerId = iprot.readI64();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      elif fid == 4:
7273 
        if ftype == TType.I64:
7274 
          self.warehouseId = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
3451 chandransh 7277 
      elif fid == 5:
7278 
        if ftype == TType.BOOL:
7279 
          self.cod = iprot.readBool();
7280 
        else:
7281 
          iprot.skip(ftype)
3427 chandransh 7282 
      else:
7283 
        iprot.skip(ftype)
7284 
      iprot.readFieldEnd()
7285 
    iprot.readStructEnd()
7286 
 
7287 
  def write(self, oprot):
7288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7290 
      return
7291 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7292 
    if self.fromShippingDate is not None:
3427 chandransh 7293 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7294 
      oprot.writeI64(self.fromShippingDate)
7295 
      oprot.writeFieldEnd()
3431 rajveer 7296 
    if self.toShippingDate is not None:
3427 chandransh 7297 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7298 
      oprot.writeI64(self.toShippingDate)
7299 
      oprot.writeFieldEnd()
3431 rajveer 7300 
    if self.providerId is not None:
3427 chandransh 7301 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7302 
      oprot.writeI64(self.providerId)
7303 
      oprot.writeFieldEnd()
3431 rajveer 7304 
    if self.warehouseId is not None:
3427 chandransh 7305 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7306 
      oprot.writeI64(self.warehouseId)
7307 
      oprot.writeFieldEnd()
3451 chandransh 7308 
    if self.cod is not None:
7309 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7310 
      oprot.writeBool(self.cod)
7311 
      oprot.writeFieldEnd()
3427 chandransh 7312 
    oprot.writeFieldStop()
7313 
    oprot.writeStructEnd()
7314 
 
3431 rajveer 7315 
  def validate(self):
7316 
    return
7317 
 
7318 
 
3427 chandransh 7319 
  def __repr__(self):
7320 
    L = ['%s=%r' % (key, value)
7321 
      for key, value in self.__dict__.iteritems()]
7322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7323 
 
7324 
  def __eq__(self, other):
7325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7326 
 
7327 
  def __ne__(self, other):
7328 
    return not (self == other)
7329 
 
7330 
class getOrdersByShippingDate_result:
7331 
  """
7332 
  Attributes:
7333 
   - success
7334 
   - ex
7335 
  """
7336 
 
7337 
  thrift_spec = (
7338 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7340 
  )
7341 
 
7342 
  def __init__(self, success=None, ex=None,):
7343 
    self.success = success
7344 
    self.ex = ex
7345 
 
7346 
  def read(self, iprot):
7347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7349 
      return
7350 
    iprot.readStructBegin()
7351 
    while True:
7352 
      (fname, ftype, fid) = iprot.readFieldBegin()
7353 
      if ftype == TType.STOP:
7354 
        break
7355 
      if fid == 0:
7356 
        if ftype == TType.LIST:
7357 
          self.success = []
4133 chandransh 7358 
          (_etype66, _size63) = iprot.readListBegin()
7359 
          for _i67 in xrange(_size63):
7360 
            _elem68 = Order()
7361 
            _elem68.read(iprot)
7362 
            self.success.append(_elem68)
3427 chandransh 7363 
          iprot.readListEnd()
7364 
        else:
7365 
          iprot.skip(ftype)
7366 
      elif fid == 1:
7367 
        if ftype == TType.STRUCT:
7368 
          self.ex = TransactionServiceException()
7369 
          self.ex.read(iprot)
7370 
        else:
7371 
          iprot.skip(ftype)
7372 
      else:
7373 
        iprot.skip(ftype)
7374 
      iprot.readFieldEnd()
7375 
    iprot.readStructEnd()
7376 
 
7377 
  def write(self, oprot):
7378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7380 
      return
7381 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7382 
    if self.success is not None:
3427 chandransh 7383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7385 
      for iter69 in self.success:
7386 
        iter69.write(oprot)
3427 chandransh 7387 
      oprot.writeListEnd()
7388 
      oprot.writeFieldEnd()
3431 rajveer 7389 
    if self.ex is not None:
3427 chandransh 7390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7391 
      self.ex.write(oprot)
7392 
      oprot.writeFieldEnd()
7393 
    oprot.writeFieldStop()
7394 
    oprot.writeStructEnd()
7395 
 
3431 rajveer 7396 
  def validate(self):
7397 
    return
7398 
 
7399 
 
3427 chandransh 7400 
  def __repr__(self):
7401 
    L = ['%s=%r' % (key, value)
7402 
      for key, value in self.__dict__.iteritems()]
7403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7404 
 
7405 
  def __eq__(self, other):
7406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7407 
 
7408 
  def __ne__(self, other):
7409 
    return not (self == other)
7410 
 
1382 varun.gupt 7411 
class getReturnableOrdersForCustomer_args:
7412 
  """
7413 
  Attributes:
7414 
   - customer_id
7415 
   - limit
7416 
  """
7417 
 
7418 
  thrift_spec = (
7419 
    None, # 0
7420 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7421 
    (2, TType.I64, 'limit', None, None, ), # 2
7422 
  )
7423 
 
7424 
  def __init__(self, customer_id=None, limit=None,):
7425 
    self.customer_id = customer_id
7426 
    self.limit = limit
7427 
 
7428 
  def read(self, iprot):
7429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7431 
      return
7432 
    iprot.readStructBegin()
7433 
    while True:
7434 
      (fname, ftype, fid) = iprot.readFieldBegin()
7435 
      if ftype == TType.STOP:
7436 
        break
7437 
      if fid == 1:
7438 
        if ftype == TType.I64:
7439 
          self.customer_id = iprot.readI64();
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      elif fid == 2:
7443 
        if ftype == TType.I64:
7444 
          self.limit = iprot.readI64();
7445 
        else:
7446 
          iprot.skip(ftype)
7447 
      else:
7448 
        iprot.skip(ftype)
7449 
      iprot.readFieldEnd()
7450 
    iprot.readStructEnd()
7451 
 
7452 
  def write(self, oprot):
7453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7455 
      return
7456 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7457 
    if self.customer_id is not None:
1382 varun.gupt 7458 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7459 
      oprot.writeI64(self.customer_id)
7460 
      oprot.writeFieldEnd()
3431 rajveer 7461 
    if self.limit is not None:
1382 varun.gupt 7462 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7463 
      oprot.writeI64(self.limit)
7464 
      oprot.writeFieldEnd()
7465 
    oprot.writeFieldStop()
7466 
    oprot.writeStructEnd()
7467 
 
3431 rajveer 7468 
  def validate(self):
7469 
    return
7470 
 
7471 
 
1382 varun.gupt 7472 
  def __repr__(self):
7473 
    L = ['%s=%r' % (key, value)
7474 
      for key, value in self.__dict__.iteritems()]
7475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7476 
 
7477 
  def __eq__(self, other):
7478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7479 
 
7480 
  def __ne__(self, other):
7481 
    return not (self == other)
7482 
 
7483 
class getReturnableOrdersForCustomer_result:
7484 
  """
7485 
  Attributes:
7486 
   - success
7487 
   - ex
7488 
  """
7489 
 
7490 
  thrift_spec = (
7491 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7493 
  )
7494 
 
7495 
  def __init__(self, success=None, ex=None,):
7496 
    self.success = success
7497 
    self.ex = ex
7498 
 
7499 
  def read(self, iprot):
7500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7502 
      return
7503 
    iprot.readStructBegin()
7504 
    while True:
7505 
      (fname, ftype, fid) = iprot.readFieldBegin()
7506 
      if ftype == TType.STOP:
7507 
        break
7508 
      if fid == 0:
7509 
        if ftype == TType.LIST:
7510 
          self.success = []
4133 chandransh 7511 
          (_etype73, _size70) = iprot.readListBegin()
7512 
          for _i74 in xrange(_size70):
7513 
            _elem75 = iprot.readI64();
7514 
            self.success.append(_elem75)
1382 varun.gupt 7515 
          iprot.readListEnd()
7516 
        else:
7517 
          iprot.skip(ftype)
7518 
      elif fid == 1:
7519 
        if ftype == TType.STRUCT:
7520 
          self.ex = TransactionServiceException()
7521 
          self.ex.read(iprot)
7522 
        else:
7523 
          iprot.skip(ftype)
7524 
      else:
7525 
        iprot.skip(ftype)
7526 
      iprot.readFieldEnd()
7527 
    iprot.readStructEnd()
7528 
 
7529 
  def write(self, oprot):
7530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7532 
      return
7533 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7534 
    if self.success is not None:
1382 varun.gupt 7535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7536 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7537 
      for iter76 in self.success:
7538 
        oprot.writeI64(iter76)
1382 varun.gupt 7539 
      oprot.writeListEnd()
7540 
      oprot.writeFieldEnd()
3431 rajveer 7541 
    if self.ex is not None:
1382 varun.gupt 7542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7543 
      self.ex.write(oprot)
7544 
      oprot.writeFieldEnd()
7545 
    oprot.writeFieldStop()
7546 
    oprot.writeStructEnd()
7547 
 
3431 rajveer 7548 
  def validate(self):
7549 
    return
7550 
 
7551 
 
1382 varun.gupt 7552 
  def __repr__(self):
7553 
    L = ['%s=%r' % (key, value)
7554 
      for key, value in self.__dict__.iteritems()]
7555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7556 
 
7557 
  def __eq__(self, other):
7558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7559 
 
7560 
  def __ne__(self, other):
7561 
    return not (self == other)
7562 
 
7563 
class getCancellableOrdersForCustomer_args:
7564 
  """
7565 
  Attributes:
7566 
   - customer_id
7567 
   - limit
7568 
  """
7569 
 
7570 
  thrift_spec = (
7571 
    None, # 0
7572 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7573 
    (2, TType.I64, 'limit', None, None, ), # 2
7574 
  )
7575 
 
7576 
  def __init__(self, customer_id=None, limit=None,):
7577 
    self.customer_id = customer_id
7578 
    self.limit = limit
7579 
 
7580 
  def read(self, iprot):
7581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7583 
      return
7584 
    iprot.readStructBegin()
7585 
    while True:
7586 
      (fname, ftype, fid) = iprot.readFieldBegin()
7587 
      if ftype == TType.STOP:
7588 
        break
7589 
      if fid == 1:
7590 
        if ftype == TType.I64:
7591 
          self.customer_id = iprot.readI64();
7592 
        else:
7593 
          iprot.skip(ftype)
7594 
      elif fid == 2:
7595 
        if ftype == TType.I64:
7596 
          self.limit = iprot.readI64();
7597 
        else:
7598 
          iprot.skip(ftype)
7599 
      else:
7600 
        iprot.skip(ftype)
7601 
      iprot.readFieldEnd()
7602 
    iprot.readStructEnd()
7603 
 
7604 
  def write(self, oprot):
7605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7607 
      return
7608 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7609 
    if self.customer_id is not None:
1382 varun.gupt 7610 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7611 
      oprot.writeI64(self.customer_id)
7612 
      oprot.writeFieldEnd()
3431 rajveer 7613 
    if self.limit is not None:
1382 varun.gupt 7614 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7615 
      oprot.writeI64(self.limit)
7616 
      oprot.writeFieldEnd()
7617 
    oprot.writeFieldStop()
7618 
    oprot.writeStructEnd()
7619 
 
3431 rajveer 7620 
  def validate(self):
7621 
    return
7622 
 
7623 
 
1382 varun.gupt 7624 
  def __repr__(self):
7625 
    L = ['%s=%r' % (key, value)
7626 
      for key, value in self.__dict__.iteritems()]
7627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7628 
 
7629 
  def __eq__(self, other):
7630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7631 
 
7632 
  def __ne__(self, other):
7633 
    return not (self == other)
7634 
 
7635 
class getCancellableOrdersForCustomer_result:
7636 
  """
7637 
  Attributes:
7638 
   - success
7639 
   - ex
7640 
  """
7641 
 
7642 
  thrift_spec = (
7643 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7645 
  )
7646 
 
7647 
  def __init__(self, success=None, ex=None,):
7648 
    self.success = success
7649 
    self.ex = ex
7650 
 
7651 
  def read(self, iprot):
7652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7654 
      return
7655 
    iprot.readStructBegin()
7656 
    while True:
7657 
      (fname, ftype, fid) = iprot.readFieldBegin()
7658 
      if ftype == TType.STOP:
7659 
        break
7660 
      if fid == 0:
7661 
        if ftype == TType.LIST:
7662 
          self.success = []
4133 chandransh 7663 
          (_etype80, _size77) = iprot.readListBegin()
7664 
          for _i81 in xrange(_size77):
7665 
            _elem82 = iprot.readI64();
7666 
            self.success.append(_elem82)
1382 varun.gupt 7667 
          iprot.readListEnd()
7668 
        else:
7669 
          iprot.skip(ftype)
7670 
      elif fid == 1:
7671 
        if ftype == TType.STRUCT:
7672 
          self.ex = TransactionServiceException()
7673 
          self.ex.read(iprot)
7674 
        else:
7675 
          iprot.skip(ftype)
7676 
      else:
7677 
        iprot.skip(ftype)
7678 
      iprot.readFieldEnd()
7679 
    iprot.readStructEnd()
7680 
 
7681 
  def write(self, oprot):
7682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7684 
      return
7685 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7686 
    if self.success is not None:
1382 varun.gupt 7687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7688 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7689 
      for iter83 in self.success:
7690 
        oprot.writeI64(iter83)
1382 varun.gupt 7691 
      oprot.writeListEnd()
7692 
      oprot.writeFieldEnd()
3431 rajveer 7693 
    if self.ex is not None:
1382 varun.gupt 7694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7695 
      self.ex.write(oprot)
7696 
      oprot.writeFieldEnd()
7697 
    oprot.writeFieldStop()
7698 
    oprot.writeStructEnd()
7699 
 
3431 rajveer 7700 
  def validate(self):
7701 
    return
7702 
 
7703 
 
1382 varun.gupt 7704 
  def __repr__(self):
7705 
    L = ['%s=%r' % (key, value)
7706 
      for key, value in self.__dict__.iteritems()]
7707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7708 
 
7709 
  def __eq__(self, other):
7710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7711 
 
7712 
  def __ne__(self, other):
7713 
    return not (self == other)
7714 
 
483 rajveer 7715 
class changeOrderStatus_args:
94 ashish 7716 
  """
7717 
  Attributes:
483 rajveer 7718 
   - orderId
7719 
   - status
7720 
   - description
94 ashish 7721 
  """
7722 
 
7723 
  thrift_spec = (
7724 
    None, # 0
483 rajveer 7725 
    (1, TType.I64, 'orderId', None, None, ), # 1
7726 
    (2, TType.I32, 'status', None, None, ), # 2
7727 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7728 
  )
7729 
 
483 rajveer 7730 
  def __init__(self, orderId=None, status=None, description=None,):
7731 
    self.orderId = orderId
7732 
    self.status = status
7733 
    self.description = description
94 ashish 7734 
 
7735 
  def read(self, iprot):
7736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7738 
      return
7739 
    iprot.readStructBegin()
7740 
    while True:
7741 
      (fname, ftype, fid) = iprot.readFieldBegin()
7742 
      if ftype == TType.STOP:
7743 
        break
7744 
      if fid == 1:
7745 
        if ftype == TType.I64:
483 rajveer 7746 
          self.orderId = iprot.readI64();
94 ashish 7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      elif fid == 2:
483 rajveer 7750 
        if ftype == TType.I32:
7751 
          self.status = iprot.readI32();
94 ashish 7752 
        else:
7753 
          iprot.skip(ftype)
483 rajveer 7754 
      elif fid == 3:
7755 
        if ftype == TType.STRING:
7756 
          self.description = iprot.readString();
7757 
        else:
7758 
          iprot.skip(ftype)
94 ashish 7759 
      else:
7760 
        iprot.skip(ftype)
7761 
      iprot.readFieldEnd()
7762 
    iprot.readStructEnd()
7763 
 
7764 
  def write(self, oprot):
7765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7767 
      return
483 rajveer 7768 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7769 
    if self.orderId is not None:
483 rajveer 7770 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7771 
      oprot.writeI64(self.orderId)
94 ashish 7772 
      oprot.writeFieldEnd()
3431 rajveer 7773 
    if self.status is not None:
483 rajveer 7774 
      oprot.writeFieldBegin('status', TType.I32, 2)
7775 
      oprot.writeI32(self.status)
94 ashish 7776 
      oprot.writeFieldEnd()
3431 rajveer 7777 
    if self.description is not None:
483 rajveer 7778 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7779 
      oprot.writeString(self.description)
7780 
      oprot.writeFieldEnd()
94 ashish 7781 
    oprot.writeFieldStop()
7782 
    oprot.writeStructEnd()
7783 
 
3431 rajveer 7784 
  def validate(self):
7785 
    return
7786 
 
7787 
 
94 ashish 7788 
  def __repr__(self):
7789 
    L = ['%s=%r' % (key, value)
7790 
      for key, value in self.__dict__.iteritems()]
7791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7792 
 
7793 
  def __eq__(self, other):
7794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7795 
 
7796 
  def __ne__(self, other):
7797 
    return not (self == other)
7798 
 
483 rajveer 7799 
class changeOrderStatus_result:
94 ashish 7800 
  """
7801 
  Attributes:
7802 
   - success
7803 
   - ex
7804 
  """
7805 
 
7806 
  thrift_spec = (
7807 
    (0, TType.BOOL, 'success', None, None, ), # 0
7808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7809 
  )
7810 
 
7811 
  def __init__(self, success=None, ex=None,):
7812 
    self.success = success
7813 
    self.ex = ex
7814 
 
7815 
  def read(self, iprot):
7816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7818 
      return
7819 
    iprot.readStructBegin()
7820 
    while True:
7821 
      (fname, ftype, fid) = iprot.readFieldBegin()
7822 
      if ftype == TType.STOP:
7823 
        break
7824 
      if fid == 0:
7825 
        if ftype == TType.BOOL:
7826 
          self.success = iprot.readBool();
7827 
        else:
7828 
          iprot.skip(ftype)
7829 
      elif fid == 1:
7830 
        if ftype == TType.STRUCT:
7831 
          self.ex = TransactionServiceException()
7832 
          self.ex.read(iprot)
7833 
        else:
7834 
          iprot.skip(ftype)
7835 
      else:
7836 
        iprot.skip(ftype)
7837 
      iprot.readFieldEnd()
7838 
    iprot.readStructEnd()
7839 
 
7840 
  def write(self, oprot):
7841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7843 
      return
483 rajveer 7844 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7845 
    if self.success is not None:
94 ashish 7846 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7847 
      oprot.writeBool(self.success)
7848 
      oprot.writeFieldEnd()
3431 rajveer 7849 
    if self.ex is not None:
94 ashish 7850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7851 
      self.ex.write(oprot)
7852 
      oprot.writeFieldEnd()
7853 
    oprot.writeFieldStop()
7854 
    oprot.writeStructEnd()
7855 
 
3431 rajveer 7856 
  def validate(self):
7857 
    return
7858 
 
7859 
 
94 ashish 7860 
  def __repr__(self):
7861 
    L = ['%s=%r' % (key, value)
7862 
      for key, value in self.__dict__.iteritems()]
7863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7864 
 
7865 
  def __eq__(self, other):
7866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7867 
 
7868 
  def __ne__(self, other):
7869 
    return not (self == other)
7870 
 
3064 chandransh 7871 
class getOrdersForTransaction_args:
494 rajveer 7872 
  """
7873 
  Attributes:
3064 chandransh 7874 
   - transactionId
7875 
   - customerId
494 rajveer 7876 
  """
7877 
 
7878 
  thrift_spec = (
7879 
    None, # 0
3064 chandransh 7880 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7881 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7882 
  )
7883 
 
3064 chandransh 7884 
  def __init__(self, transactionId=None, customerId=None,):
7885 
    self.transactionId = transactionId
7886 
    self.customerId = customerId
494 rajveer 7887 
 
7888 
  def read(self, iprot):
7889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7891 
      return
7892 
    iprot.readStructBegin()
7893 
    while True:
7894 
      (fname, ftype, fid) = iprot.readFieldBegin()
7895 
      if ftype == TType.STOP:
7896 
        break
7897 
      if fid == 1:
7898 
        if ftype == TType.I64:
3064 chandransh 7899 
          self.transactionId = iprot.readI64();
494 rajveer 7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      elif fid == 2:
3064 chandransh 7903 
        if ftype == TType.I64:
7904 
          self.customerId = iprot.readI64();
494 rajveer 7905 
        else:
7906 
          iprot.skip(ftype)
7907 
      else:
7908 
        iprot.skip(ftype)
7909 
      iprot.readFieldEnd()
7910 
    iprot.readStructEnd()
7911 
 
7912 
  def write(self, oprot):
7913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7915 
      return
3064 chandransh 7916 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7917 
    if self.transactionId is not None:
3064 chandransh 7918 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7919 
      oprot.writeI64(self.transactionId)
494 rajveer 7920 
      oprot.writeFieldEnd()
3431 rajveer 7921 
    if self.customerId is not None:
3064 chandransh 7922 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7923 
      oprot.writeI64(self.customerId)
494 rajveer 7924 
      oprot.writeFieldEnd()
7925 
    oprot.writeFieldStop()
7926 
    oprot.writeStructEnd()
7927 
 
3431 rajveer 7928 
  def validate(self):
7929 
    return
7930 
 
7931 
 
494 rajveer 7932 
  def __repr__(self):
7933 
    L = ['%s=%r' % (key, value)
7934 
      for key, value in self.__dict__.iteritems()]
7935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7936 
 
7937 
  def __eq__(self, other):
7938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7939 
 
7940 
  def __ne__(self, other):
7941 
    return not (self == other)
7942 
 
3064 chandransh 7943 
class getOrdersForTransaction_result:
494 rajveer 7944 
  """
7945 
  Attributes:
7946 
   - success
7947 
   - ex
7948 
  """
7949 
 
7950 
  thrift_spec = (
3064 chandransh 7951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7953 
  )
7954 
 
7955 
  def __init__(self, success=None, ex=None,):
7956 
    self.success = success
7957 
    self.ex = ex
7958 
 
7959 
  def read(self, iprot):
7960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7962 
      return
7963 
    iprot.readStructBegin()
7964 
    while True:
7965 
      (fname, ftype, fid) = iprot.readFieldBegin()
7966 
      if ftype == TType.STOP:
7967 
        break
7968 
      if fid == 0:
3064 chandransh 7969 
        if ftype == TType.LIST:
7970 
          self.success = []
4133 chandransh 7971 
          (_etype87, _size84) = iprot.readListBegin()
7972 
          for _i88 in xrange(_size84):
7973 
            _elem89 = Order()
7974 
            _elem89.read(iprot)
7975 
            self.success.append(_elem89)
3064 chandransh 7976 
          iprot.readListEnd()
494 rajveer 7977 
        else:
7978 
          iprot.skip(ftype)
7979 
      elif fid == 1:
7980 
        if ftype == TType.STRUCT:
7981 
          self.ex = TransactionServiceException()
7982 
          self.ex.read(iprot)
7983 
        else:
7984 
          iprot.skip(ftype)
7985 
      else:
7986 
        iprot.skip(ftype)
7987 
      iprot.readFieldEnd()
7988 
    iprot.readStructEnd()
7989 
 
7990 
  def write(self, oprot):
7991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7993 
      return
3064 chandransh 7994 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7995 
    if self.success is not None:
3064 chandransh 7996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7998 
      for iter90 in self.success:
7999 
        iter90.write(oprot)
3064 chandransh 8000 
      oprot.writeListEnd()
494 rajveer 8001 
      oprot.writeFieldEnd()
3431 rajveer 8002 
    if self.ex is not None:
494 rajveer 8003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8004 
      self.ex.write(oprot)
8005 
      oprot.writeFieldEnd()
8006 
    oprot.writeFieldStop()
8007 
    oprot.writeStructEnd()
8008 
 
3431 rajveer 8009 
  def validate(self):
8010 
    return
8011 
 
8012 
 
494 rajveer 8013 
  def __repr__(self):
8014 
    L = ['%s=%r' % (key, value)
8015 
      for key, value in self.__dict__.iteritems()]
8016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8017 
 
8018 
  def __eq__(self, other):
8019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8020 
 
8021 
  def __ne__(self, other):
8022 
    return not (self == other)
8023 
 
3064 chandransh 8024 
class getOrdersForCustomer_args:
1149 chandransh 8025 
  """
8026 
  Attributes:
3064 chandransh 8027 
   - customerId
8028 
   - from_date
8029 
   - to_date
8030 
   - statuses
1149 chandransh 8031 
  """
8032 
 
8033 
  thrift_spec = (
8034 
    None, # 0
3064 chandransh 8035 
    (1, TType.I64, 'customerId', None, None, ), # 1
8036 
    (2, TType.I64, 'from_date', None, None, ), # 2
8037 
    (3, TType.I64, 'to_date', None, None, ), # 3
8038 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8039 
  )
8040 
 
3064 chandransh 8041 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8042 
    self.customerId = customerId
8043 
    self.from_date = from_date
8044 
    self.to_date = to_date
8045 
    self.statuses = statuses
1149 chandransh 8046 
 
8047 
  def read(self, iprot):
8048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8050 
      return
8051 
    iprot.readStructBegin()
8052 
    while True:
8053 
      (fname, ftype, fid) = iprot.readFieldBegin()
8054 
      if ftype == TType.STOP:
8055 
        break
8056 
      if fid == 1:
8057 
        if ftype == TType.I64:
3064 chandransh 8058 
          self.customerId = iprot.readI64();
1149 chandransh 8059 
        else:
8060 
          iprot.skip(ftype)
8061 
      elif fid == 2:
8062 
        if ftype == TType.I64:
3064 chandransh 8063 
          self.from_date = iprot.readI64();
1149 chandransh 8064 
        else:
8065 
          iprot.skip(ftype)
2783 chandransh 8066 
      elif fid == 3:
8067 
        if ftype == TType.I64:
3064 chandransh 8068 
          self.to_date = iprot.readI64();
2783 chandransh 8069 
        else:
8070 
          iprot.skip(ftype)
8071 
      elif fid == 4:
3064 chandransh 8072 
        if ftype == TType.LIST:
8073 
          self.statuses = []
4133 chandransh 8074 
          (_etype94, _size91) = iprot.readListBegin()
8075 
          for _i95 in xrange(_size91):
8076 
            _elem96 = iprot.readI32();
8077 
            self.statuses.append(_elem96)
3064 chandransh 8078 
          iprot.readListEnd()
2783 chandransh 8079 
        else:
8080 
          iprot.skip(ftype)
1149 chandransh 8081 
      else:
8082 
        iprot.skip(ftype)
8083 
      iprot.readFieldEnd()
8084 
    iprot.readStructEnd()
8085 
 
8086 
  def write(self, oprot):
8087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8089 
      return
3064 chandransh 8090 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8091 
    if self.customerId is not None:
3064 chandransh 8092 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8093 
      oprot.writeI64(self.customerId)
1149 chandransh 8094 
      oprot.writeFieldEnd()
3431 rajveer 8095 
    if self.from_date is not None:
3064 chandransh 8096 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8097 
      oprot.writeI64(self.from_date)
1149 chandransh 8098 
      oprot.writeFieldEnd()
3431 rajveer 8099 
    if self.to_date is not None:
3064 chandransh 8100 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8101 
      oprot.writeI64(self.to_date)
2783 chandransh 8102 
      oprot.writeFieldEnd()
3431 rajveer 8103 
    if self.statuses is not None:
3064 chandransh 8104 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8105 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8106 
      for iter97 in self.statuses:
8107 
        oprot.writeI32(iter97)
3064 chandransh 8108 
      oprot.writeListEnd()
2783 chandransh 8109 
      oprot.writeFieldEnd()
1149 chandransh 8110 
    oprot.writeFieldStop()
8111 
    oprot.writeStructEnd()
8112 
 
3431 rajveer 8113 
  def validate(self):
8114 
    return
8115 
 
8116 
 
1149 chandransh 8117 
  def __repr__(self):
8118 
    L = ['%s=%r' % (key, value)
8119 
      for key, value in self.__dict__.iteritems()]
8120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8121 
 
8122 
  def __eq__(self, other):
8123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8124 
 
8125 
  def __ne__(self, other):
8126 
    return not (self == other)
8127 
 
3064 chandransh 8128 
class getOrdersForCustomer_result:
1149 chandransh 8129 
  """
8130 
  Attributes:
8131 
   - success
8132 
   - ex
8133 
  """
8134 
 
8135 
  thrift_spec = (
3064 chandransh 8136 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8138 
  )
8139 
 
8140 
  def __init__(self, success=None, ex=None,):
8141 
    self.success = success
8142 
    self.ex = ex
8143 
 
8144 
  def read(self, iprot):
8145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8147 
      return
8148 
    iprot.readStructBegin()
8149 
    while True:
8150 
      (fname, ftype, fid) = iprot.readFieldBegin()
8151 
      if ftype == TType.STOP:
8152 
        break
8153 
      if fid == 0:
3064 chandransh 8154 
        if ftype == TType.LIST:
8155 
          self.success = []
4133 chandransh 8156 
          (_etype101, _size98) = iprot.readListBegin()
8157 
          for _i102 in xrange(_size98):
8158 
            _elem103 = Order()
8159 
            _elem103.read(iprot)
8160 
            self.success.append(_elem103)
3064 chandransh 8161 
          iprot.readListEnd()
1149 chandransh 8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      elif fid == 1:
8165 
        if ftype == TType.STRUCT:
8166 
          self.ex = TransactionServiceException()
8167 
          self.ex.read(iprot)
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      else:
8171 
        iprot.skip(ftype)
8172 
      iprot.readFieldEnd()
8173 
    iprot.readStructEnd()
8174 
 
8175 
  def write(self, oprot):
8176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8178 
      return
3064 chandransh 8179 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8180 
    if self.success is not None:
3064 chandransh 8181 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8182 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8183 
      for iter104 in self.success:
8184 
        iter104.write(oprot)
3064 chandransh 8185 
      oprot.writeListEnd()
1149 chandransh 8186 
      oprot.writeFieldEnd()
3431 rajveer 8187 
    if self.ex is not None:
1149 chandransh 8188 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8189 
      self.ex.write(oprot)
8190 
      oprot.writeFieldEnd()
8191 
    oprot.writeFieldStop()
8192 
    oprot.writeStructEnd()
8193 
 
3431 rajveer 8194 
  def validate(self):
8195 
    return
8196 
 
8197 
 
1149 chandransh 8198 
  def __repr__(self):
8199 
    L = ['%s=%r' % (key, value)
8200 
      for key, value in self.__dict__.iteritems()]
8201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8202 
 
8203 
  def __eq__(self, other):
8204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8205 
 
8206 
  def __ne__(self, other):
8207 
    return not (self == other)
8208 
 
3064 chandransh 8209 
class createOrder_args:
921 rajveer 8210 
  """
8211 
  Attributes:
3064 chandransh 8212 
   - order
921 rajveer 8213 
  """
8214 
 
8215 
  thrift_spec = (
8216 
    None, # 0
3064 chandransh 8217 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8218 
  )
8219 
 
3064 chandransh 8220 
  def __init__(self, order=None,):
8221 
    self.order = order
921 rajveer 8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 1:
3064 chandransh 8233 
        if ftype == TType.STRUCT:
8234 
          self.order = Order()
8235 
          self.order.read(iprot)
921 rajveer 8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      else:
8239 
        iprot.skip(ftype)
8240 
      iprot.readFieldEnd()
8241 
    iprot.readStructEnd()
8242 
 
8243 
  def write(self, oprot):
8244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8246 
      return
3064 chandransh 8247 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8248 
    if self.order is not None:
3064 chandransh 8249 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8250 
      self.order.write(oprot)
921 rajveer 8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
921 rajveer 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
3064 chandransh 8270 
class createOrder_result:
921 rajveer 8271 
  """
8272 
  Attributes:
8273 
   - success
8274 
   - ex
8275 
  """
8276 
 
8277 
  thrift_spec = (
3064 chandransh 8278 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8280 
  )
8281 
 
8282 
  def __init__(self, success=None, ex=None,):
8283 
    self.success = success
8284 
    self.ex = ex
8285 
 
8286 
  def read(self, iprot):
8287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8289 
      return
8290 
    iprot.readStructBegin()
8291 
    while True:
8292 
      (fname, ftype, fid) = iprot.readFieldBegin()
8293 
      if ftype == TType.STOP:
8294 
        break
8295 
      if fid == 0:
3064 chandransh 8296 
        if ftype == TType.I64:
8297 
          self.success = iprot.readI64();
921 rajveer 8298 
        else:
8299 
          iprot.skip(ftype)
8300 
      elif fid == 1:
8301 
        if ftype == TType.STRUCT:
8302 
          self.ex = TransactionServiceException()
8303 
          self.ex.read(iprot)
8304 
        else:
8305 
          iprot.skip(ftype)
8306 
      else:
8307 
        iprot.skip(ftype)
8308 
      iprot.readFieldEnd()
8309 
    iprot.readStructEnd()
8310 
 
8311 
  def write(self, oprot):
8312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8314 
      return
3064 chandransh 8315 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8316 
    if self.success is not None:
3064 chandransh 8317 
      oprot.writeFieldBegin('success', TType.I64, 0)
8318 
      oprot.writeI64(self.success)
921 rajveer 8319 
      oprot.writeFieldEnd()
3431 rajveer 8320 
    if self.ex is not None:
921 rajveer 8321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8322 
      self.ex.write(oprot)
8323 
      oprot.writeFieldEnd()
8324 
    oprot.writeFieldStop()
8325 
    oprot.writeStructEnd()
8326 
 
3431 rajveer 8327 
  def validate(self):
8328 
    return
8329 
 
8330 
 
921 rajveer 8331 
  def __repr__(self):
8332 
    L = ['%s=%r' % (key, value)
8333 
      for key, value in self.__dict__.iteritems()]
8334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8335 
 
8336 
  def __eq__(self, other):
8337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8338 
 
8339 
  def __ne__(self, other):
8340 
    return not (self == other)
8341 
 
3064 chandransh 8342 
class getOrder_args:
921 rajveer 8343 
  """
8344 
  Attributes:
3064 chandransh 8345 
   - id
921 rajveer 8346 
  """
8347 
 
8348 
  thrift_spec = (
8349 
    None, # 0
3064 chandransh 8350 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8351 
  )
8352 
 
3064 chandransh 8353 
  def __init__(self, id=None,):
8354 
    self.id = id
921 rajveer 8355 
 
8356 
  def read(self, iprot):
8357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8359 
      return
8360 
    iprot.readStructBegin()
8361 
    while True:
8362 
      (fname, ftype, fid) = iprot.readFieldBegin()
8363 
      if ftype == TType.STOP:
8364 
        break
8365 
      if fid == 1:
8366 
        if ftype == TType.I64:
3064 chandransh 8367 
          self.id = iprot.readI64();
921 rajveer 8368 
        else:
8369 
          iprot.skip(ftype)
8370 
      else:
8371 
        iprot.skip(ftype)
8372 
      iprot.readFieldEnd()
8373 
    iprot.readStructEnd()
8374 
 
8375 
  def write(self, oprot):
8376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8378 
      return
3064 chandransh 8379 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8380 
    if self.id is not None:
3064 chandransh 8381 
      oprot.writeFieldBegin('id', TType.I64, 1)
8382 
      oprot.writeI64(self.id)
921 rajveer 8383 
      oprot.writeFieldEnd()
8384 
    oprot.writeFieldStop()
8385 
    oprot.writeStructEnd()
8386 
 
3431 rajveer 8387 
  def validate(self):
8388 
    return
8389 
 
8390 
 
921 rajveer 8391 
  def __repr__(self):
8392 
    L = ['%s=%r' % (key, value)
8393 
      for key, value in self.__dict__.iteritems()]
8394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8395 
 
8396 
  def __eq__(self, other):
8397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8398 
 
8399 
  def __ne__(self, other):
8400 
    return not (self == other)
8401 
 
3064 chandransh 8402 
class getOrder_result:
921 rajveer 8403 
  """
8404 
  Attributes:
8405 
   - success
8406 
   - ex
8407 
  """
8408 
 
8409 
  thrift_spec = (
3064 chandransh 8410 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8412 
  )
8413 
 
8414 
  def __init__(self, success=None, ex=None,):
8415 
    self.success = success
8416 
    self.ex = ex
8417 
 
8418 
  def read(self, iprot):
8419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8421 
      return
8422 
    iprot.readStructBegin()
8423 
    while True:
8424 
      (fname, ftype, fid) = iprot.readFieldBegin()
8425 
      if ftype == TType.STOP:
8426 
        break
8427 
      if fid == 0:
3064 chandransh 8428 
        if ftype == TType.STRUCT:
8429 
          self.success = Order()
8430 
          self.success.read(iprot)
921 rajveer 8431 
        else:
8432 
          iprot.skip(ftype)
8433 
      elif fid == 1:
8434 
        if ftype == TType.STRUCT:
8435 
          self.ex = TransactionServiceException()
8436 
          self.ex.read(iprot)
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      else:
8440 
        iprot.skip(ftype)
8441 
      iprot.readFieldEnd()
8442 
    iprot.readStructEnd()
8443 
 
8444 
  def write(self, oprot):
8445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8447 
      return
3064 chandransh 8448 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8449 
    if self.success is not None:
3064 chandransh 8450 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8451 
      self.success.write(oprot)
921 rajveer 8452 
      oprot.writeFieldEnd()
3431 rajveer 8453 
    if self.ex is not None:
921 rajveer 8454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8455 
      self.ex.write(oprot)
8456 
      oprot.writeFieldEnd()
8457 
    oprot.writeFieldStop()
8458 
    oprot.writeStructEnd()
8459 
 
3431 rajveer 8460 
  def validate(self):
8461 
    return
8462 
 
8463 
 
921 rajveer 8464 
  def __repr__(self):
8465 
    L = ['%s=%r' % (key, value)
8466 
      for key, value in self.__dict__.iteritems()]
8467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8468 
 
8469 
  def __eq__(self, other):
8470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8471 
 
8472 
  def __ne__(self, other):
8473 
    return not (self == other)
8474 
 
3064 chandransh 8475 
class getLineItemsForOrder_args:
94 ashish 8476 
  """
8477 
  Attributes:
3064 chandransh 8478 
   - orderId
94 ashish 8479 
  """
8480 
 
8481 
  thrift_spec = (
8482 
    None, # 0
3064 chandransh 8483 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8484 
  )
8485 
 
3064 chandransh 8486 
  def __init__(self, orderId=None,):
8487 
    self.orderId = orderId
94 ashish 8488 
 
8489 
  def read(self, iprot):
8490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8492 
      return
8493 
    iprot.readStructBegin()
8494 
    while True:
8495 
      (fname, ftype, fid) = iprot.readFieldBegin()
8496 
      if ftype == TType.STOP:
8497 
        break
8498 
      if fid == 1:
8499 
        if ftype == TType.I64:
3064 chandransh 8500 
          self.orderId = iprot.readI64();
94 ashish 8501 
        else:
8502 
          iprot.skip(ftype)
8503 
      else:
8504 
        iprot.skip(ftype)
8505 
      iprot.readFieldEnd()
8506 
    iprot.readStructEnd()
8507 
 
8508 
  def write(self, oprot):
8509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8511 
      return
3064 chandransh 8512 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8513 
    if self.orderId is not None:
3064 chandransh 8514 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8515 
      oprot.writeI64(self.orderId)
94 ashish 8516 
      oprot.writeFieldEnd()
8517 
    oprot.writeFieldStop()
8518 
    oprot.writeStructEnd()
8519 
 
3431 rajveer 8520 
  def validate(self):
8521 
    return
8522 
 
8523 
 
94 ashish 8524 
  def __repr__(self):
8525 
    L = ['%s=%r' % (key, value)
8526 
      for key, value in self.__dict__.iteritems()]
8527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8528 
 
8529 
  def __eq__(self, other):
8530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8531 
 
8532 
  def __ne__(self, other):
8533 
    return not (self == other)
8534 
 
3064 chandransh 8535 
class getLineItemsForOrder_result:
94 ashish 8536 
  """
8537 
  Attributes:
8538 
   - success
8539 
   - ex
8540 
  """
8541 
 
8542 
  thrift_spec = (
3064 chandransh 8543 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8545 
  )
8546 
 
8547 
  def __init__(self, success=None, ex=None,):
8548 
    self.success = success
8549 
    self.ex = ex
8550 
 
8551 
  def read(self, iprot):
8552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8554 
      return
8555 
    iprot.readStructBegin()
8556 
    while True:
8557 
      (fname, ftype, fid) = iprot.readFieldBegin()
8558 
      if ftype == TType.STOP:
8559 
        break
8560 
      if fid == 0:
483 rajveer 8561 
        if ftype == TType.LIST:
8562 
          self.success = []
4133 chandransh 8563 
          (_etype108, _size105) = iprot.readListBegin()
8564 
          for _i109 in xrange(_size105):
8565 
            _elem110 = LineItem()
8566 
            _elem110.read(iprot)
8567 
            self.success.append(_elem110)
483 rajveer 8568 
          iprot.readListEnd()
94 ashish 8569 
        else:
8570 
          iprot.skip(ftype)
8571 
      elif fid == 1:
8572 
        if ftype == TType.STRUCT:
8573 
          self.ex = TransactionServiceException()
8574 
          self.ex.read(iprot)
8575 
        else:
8576 
          iprot.skip(ftype)
8577 
      else:
8578 
        iprot.skip(ftype)
8579 
      iprot.readFieldEnd()
8580 
    iprot.readStructEnd()
8581 
 
8582 
  def write(self, oprot):
8583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8585 
      return
3064 chandransh 8586 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8587 
    if self.success is not None:
483 rajveer 8588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8590 
      for iter111 in self.success:
8591 
        iter111.write(oprot)
483 rajveer 8592 
      oprot.writeListEnd()
94 ashish 8593 
      oprot.writeFieldEnd()
3431 rajveer 8594 
    if self.ex is not None:
94 ashish 8595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8596 
      self.ex.write(oprot)
8597 
      oprot.writeFieldEnd()
8598 
    oprot.writeFieldStop()
8599 
    oprot.writeStructEnd()
8600 
 
3431 rajveer 8601 
  def validate(self):
8602 
    return
8603 
 
8604 
 
94 ashish 8605 
  def __repr__(self):
8606 
    L = ['%s=%r' % (key, value)
8607 
      for key, value in self.__dict__.iteritems()]
8608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8609 
 
8610 
  def __eq__(self, other):
8611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8612 
 
8613 
  def __ne__(self, other):
8614 
    return not (self == other)
8615 
 
3064 chandransh 8616 
class getOrderForCustomer_args:
94 ashish 8617 
  """
8618 
  Attributes:
3064 chandransh 8619 
   - orderId
483 rajveer 8620 
   - customerId
94 ashish 8621 
  """
8622 
 
8623 
  thrift_spec = (
8624 
    None, # 0
3064 chandransh 8625 
    (1, TType.I64, 'orderId', None, None, ), # 1
8626 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8627 
  )
8628 
 
3064 chandransh 8629 
  def __init__(self, orderId=None, customerId=None,):
8630 
    self.orderId = orderId
483 rajveer 8631 
    self.customerId = customerId
94 ashish 8632 
 
8633 
  def read(self, iprot):
8634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8636 
      return
8637 
    iprot.readStructBegin()
8638 
    while True:
8639 
      (fname, ftype, fid) = iprot.readFieldBegin()
8640 
      if ftype == TType.STOP:
8641 
        break
8642 
      if fid == 1:
8643 
        if ftype == TType.I64:
3064 chandransh 8644 
          self.orderId = iprot.readI64();
94 ashish 8645 
        else:
8646 
          iprot.skip(ftype)
8647 
      elif fid == 2:
8648 
        if ftype == TType.I64:
3064 chandransh 8649 
          self.customerId = iprot.readI64();
94 ashish 8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      else:
8653 
        iprot.skip(ftype)
8654 
      iprot.readFieldEnd()
8655 
    iprot.readStructEnd()
8656 
 
8657 
  def write(self, oprot):
8658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8660 
      return
3064 chandransh 8661 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8662 
    if self.orderId is not None:
3064 chandransh 8663 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8664 
      oprot.writeI64(self.orderId)
8665 
      oprot.writeFieldEnd()
3431 rajveer 8666 
    if self.customerId is not None:
3064 chandransh 8667 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8668 
      oprot.writeI64(self.customerId)
94 ashish 8669 
      oprot.writeFieldEnd()
8670 
    oprot.writeFieldStop()
8671 
    oprot.writeStructEnd()
8672 
 
3431 rajveer 8673 
  def validate(self):
8674 
    return
8675 
 
8676 
 
94 ashish 8677 
  def __repr__(self):
8678 
    L = ['%s=%r' % (key, value)
8679 
      for key, value in self.__dict__.iteritems()]
8680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8681 
 
8682 
  def __eq__(self, other):
8683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8684 
 
8685 
  def __ne__(self, other):
8686 
    return not (self == other)
8687 
 
3064 chandransh 8688 
class getOrderForCustomer_result:
94 ashish 8689 
  """
8690 
  Attributes:
8691 
   - success
8692 
   - ex
8693 
  """
8694 
 
8695 
  thrift_spec = (
3064 chandransh 8696 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8698 
  )
8699 
 
8700 
  def __init__(self, success=None, ex=None,):
8701 
    self.success = success
8702 
    self.ex = ex
8703 
 
8704 
  def read(self, iprot):
8705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8707 
      return
8708 
    iprot.readStructBegin()
8709 
    while True:
8710 
      (fname, ftype, fid) = iprot.readFieldBegin()
8711 
      if ftype == TType.STOP:
8712 
        break
8713 
      if fid == 0:
3064 chandransh 8714 
        if ftype == TType.STRUCT:
8715 
          self.success = Order()
8716 
          self.success.read(iprot)
94 ashish 8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      elif fid == 1:
8720 
        if ftype == TType.STRUCT:
8721 
          self.ex = TransactionServiceException()
8722 
          self.ex.read(iprot)
8723 
        else:
8724 
          iprot.skip(ftype)
8725 
      else:
8726 
        iprot.skip(ftype)
8727 
      iprot.readFieldEnd()
8728 
    iprot.readStructEnd()
8729 
 
8730 
  def write(self, oprot):
8731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8733 
      return
3064 chandransh 8734 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8735 
    if self.success is not None:
3064 chandransh 8736 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8737 
      self.success.write(oprot)
94 ashish 8738 
      oprot.writeFieldEnd()
3431 rajveer 8739 
    if self.ex is not None:
94 ashish 8740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8741 
      self.ex.write(oprot)
8742 
      oprot.writeFieldEnd()
8743 
    oprot.writeFieldStop()
8744 
    oprot.writeStructEnd()
8745 
 
3431 rajveer 8746 
  def validate(self):
8747 
    return
8748 
 
8749 
 
94 ashish 8750 
  def __repr__(self):
8751 
    L = ['%s=%r' % (key, value)
8752 
      for key, value in self.__dict__.iteritems()]
8753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8754 
 
8755 
  def __eq__(self, other):
8756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8757 
 
8758 
  def __ne__(self, other):
8759 
    return not (self == other)
8760 
 
3064 chandransh 8761 
class getAlerts_args:
94 ashish 8762 
  """
8763 
  Attributes:
4394 rajveer 8764 
   - type
4444 rajveer 8765 
   - warehouseId
4394 rajveer 8766 
   - status
8767 
   - timestamp
94 ashish 8768 
  """
8769 
 
8770 
  thrift_spec = (
8771 
    None, # 0
4394 rajveer 8772 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8773 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8774 
    (3, TType.I64, 'status', None, None, ), # 3
8775 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8776 
  )
8777 
 
4444 rajveer 8778 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8779 
    self.type = type
4444 rajveer 8780 
    self.warehouseId = warehouseId
4394 rajveer 8781 
    self.status = status
8782 
    self.timestamp = timestamp
94 ashish 8783 
 
8784 
  def read(self, iprot):
8785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8787 
      return
8788 
    iprot.readStructBegin()
8789 
    while True:
8790 
      (fname, ftype, fid) = iprot.readFieldBegin()
8791 
      if ftype == TType.STOP:
8792 
        break
8793 
      if fid == 1:
3064 chandransh 8794 
        if ftype == TType.I64:
4394 rajveer 8795 
          self.type = iprot.readI64();
94 ashish 8796 
        else:
8797 
          iprot.skip(ftype)
3064 chandransh 8798 
      elif fid == 2:
4394 rajveer 8799 
        if ftype == TType.I64:
4444 rajveer 8800 
          self.warehouseId = iprot.readI64();
3064 chandransh 8801 
        else:
8802 
          iprot.skip(ftype)
4394 rajveer 8803 
      elif fid == 3:
8804 
        if ftype == TType.I64:
4444 rajveer 8805 
          self.status = iprot.readI64();
8806 
        else:
8807 
          iprot.skip(ftype)
8808 
      elif fid == 4:
8809 
        if ftype == TType.I64:
4394 rajveer 8810 
          self.timestamp = iprot.readI64();
8811 
        else:
8812 
          iprot.skip(ftype)
94 ashish 8813 
      else:
8814 
        iprot.skip(ftype)
8815 
      iprot.readFieldEnd()
8816 
    iprot.readStructEnd()
8817 
 
8818 
  def write(self, oprot):
8819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8821 
      return
3064 chandransh 8822 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8823 
    if self.type is not None:
8824 
      oprot.writeFieldBegin('type', TType.I64, 1)
8825 
      oprot.writeI64(self.type)
94 ashish 8826 
      oprot.writeFieldEnd()
4444 rajveer 8827 
    if self.warehouseId is not None:
8828 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8829 
      oprot.writeI64(self.warehouseId)
8830 
      oprot.writeFieldEnd()
4394 rajveer 8831 
    if self.status is not None:
4444 rajveer 8832 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8833 
      oprot.writeI64(self.status)
3064 chandransh 8834 
      oprot.writeFieldEnd()
4394 rajveer 8835 
    if self.timestamp is not None:
4444 rajveer 8836 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8837 
      oprot.writeI64(self.timestamp)
8838 
      oprot.writeFieldEnd()
94 ashish 8839 
    oprot.writeFieldStop()
8840 
    oprot.writeStructEnd()
8841 
 
3431 rajveer 8842 
  def validate(self):
8843 
    return
8844 
 
8845 
 
94 ashish 8846 
  def __repr__(self):
8847 
    L = ['%s=%r' % (key, value)
8848 
      for key, value in self.__dict__.iteritems()]
8849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8850 
 
8851 
  def __eq__(self, other):
8852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8853 
 
8854 
  def __ne__(self, other):
8855 
    return not (self == other)
8856 
 
3064 chandransh 8857 
class getAlerts_result:
94 ashish 8858 
  """
8859 
  Attributes:
8860 
   - success
8861 
  """
8862 
 
8863 
  thrift_spec = (
3064 chandransh 8864 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8865 
  )
8866 
 
3064 chandransh 8867 
  def __init__(self, success=None,):
94 ashish 8868 
    self.success = success
8869 
 
8870 
  def read(self, iprot):
8871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8873 
      return
8874 
    iprot.readStructBegin()
8875 
    while True:
8876 
      (fname, ftype, fid) = iprot.readFieldBegin()
8877 
      if ftype == TType.STOP:
8878 
        break
8879 
      if fid == 0:
3064 chandransh 8880 
        if ftype == TType.LIST:
8881 
          self.success = []
4133 chandransh 8882 
          (_etype115, _size112) = iprot.readListBegin()
8883 
          for _i116 in xrange(_size112):
8884 
            _elem117 = Alert()
8885 
            _elem117.read(iprot)
8886 
            self.success.append(_elem117)
3064 chandransh 8887 
          iprot.readListEnd()
94 ashish 8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      else:
8891 
        iprot.skip(ftype)
8892 
      iprot.readFieldEnd()
8893 
    iprot.readStructEnd()
8894 
 
8895 
  def write(self, oprot):
8896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8898 
      return
3064 chandransh 8899 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8900 
    if self.success is not None:
3064 chandransh 8901 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8902 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8903 
      for iter118 in self.success:
8904 
        iter118.write(oprot)
3064 chandransh 8905 
      oprot.writeListEnd()
94 ashish 8906 
      oprot.writeFieldEnd()
8907 
    oprot.writeFieldStop()
8908 
    oprot.writeStructEnd()
8909 
 
3431 rajveer 8910 
  def validate(self):
8911 
    return
8912 
 
8913 
 
94 ashish 8914 
  def __repr__(self):
8915 
    L = ['%s=%r' % (key, value)
8916 
      for key, value in self.__dict__.iteritems()]
8917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8918 
 
8919 
  def __eq__(self, other):
8920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8921 
 
8922 
  def __ne__(self, other):
8923 
    return not (self == other)
8924 
 
4394 rajveer 8925 
class addAlert_args:
94 ashish 8926 
  """
8927 
  Attributes:
3064 chandransh 8928 
   - type
4444 rajveer 8929 
   - warehouseId
4394 rajveer 8930 
   - description
94 ashish 8931 
  """
8932 
 
8933 
  thrift_spec = (
8934 
    None, # 0
4394 rajveer 8935 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8936 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8937 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8938 
  )
8939 
 
4444 rajveer 8940 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8941 
    self.type = type
4444 rajveer 8942 
    self.warehouseId = warehouseId
4394 rajveer 8943 
    self.description = description
94 ashish 8944 
 
8945 
  def read(self, iprot):
8946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8948 
      return
8949 
    iprot.readStructBegin()
8950 
    while True:
8951 
      (fname, ftype, fid) = iprot.readFieldBegin()
8952 
      if ftype == TType.STOP:
8953 
        break
8954 
      if fid == 1:
8955 
        if ftype == TType.I64:
4394 rajveer 8956 
          self.type = iprot.readI64();
94 ashish 8957 
        else:
8958 
          iprot.skip(ftype)
3064 chandransh 8959 
      elif fid == 2:
4444 rajveer 8960 
        if ftype == TType.I64:
8961 
          self.warehouseId = iprot.readI64();
8962 
        else:
8963 
          iprot.skip(ftype)
8964 
      elif fid == 3:
3064 chandransh 8965 
        if ftype == TType.STRING:
4394 rajveer 8966 
          self.description = iprot.readString();
3064 chandransh 8967 
        else:
8968 
          iprot.skip(ftype)
94 ashish 8969 
      else:
8970 
        iprot.skip(ftype)
8971 
      iprot.readFieldEnd()
8972 
    iprot.readStructEnd()
8973 
 
8974 
  def write(self, oprot):
8975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8977 
      return
4394 rajveer 8978 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8979 
    if self.type is not None:
4394 rajveer 8980 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8981 
      oprot.writeI64(self.type)
8982 
      oprot.writeFieldEnd()
4444 rajveer 8983 
    if self.warehouseId is not None:
8984 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8985 
      oprot.writeI64(self.warehouseId)
8986 
      oprot.writeFieldEnd()
4394 rajveer 8987 
    if self.description is not None:
4444 rajveer 8988 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8989 
      oprot.writeString(self.description)
3064 chandransh 8990 
      oprot.writeFieldEnd()
94 ashish 8991 
    oprot.writeFieldStop()
8992 
    oprot.writeStructEnd()
8993 
 
3431 rajveer 8994 
  def validate(self):
8995 
    return
8996 
 
8997 
 
94 ashish 8998 
  def __repr__(self):
8999 
    L = ['%s=%r' % (key, value)
9000 
      for key, value in self.__dict__.iteritems()]
9001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9002 
 
9003 
  def __eq__(self, other):
9004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9005 
 
9006 
  def __ne__(self, other):
9007 
    return not (self == other)
9008 
 
4394 rajveer 9009 
class addAlert_result:
3064 chandransh 9010 
 
9011 
  thrift_spec = (
9012 
  )
9013 
 
9014 
  def read(self, iprot):
9015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9017 
      return
9018 
    iprot.readStructBegin()
9019 
    while True:
9020 
      (fname, ftype, fid) = iprot.readFieldBegin()
9021 
      if ftype == TType.STOP:
9022 
        break
9023 
      else:
9024 
        iprot.skip(ftype)
9025 
      iprot.readFieldEnd()
9026 
    iprot.readStructEnd()
9027 
 
9028 
  def write(self, oprot):
9029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9031 
      return
4394 rajveer 9032 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9033 
    oprot.writeFieldStop()
9034 
    oprot.writeStructEnd()
9035 
 
3431 rajveer 9036 
  def validate(self):
9037 
    return
9038 
 
9039 
 
3064 chandransh 9040 
  def __repr__(self):
9041 
    L = ['%s=%r' % (key, value)
9042 
      for key, value in self.__dict__.iteritems()]
9043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9044 
 
9045 
  def __eq__(self, other):
9046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9047 
 
9048 
  def __ne__(self, other):
9049 
    return not (self == other)
9050 
 
4444 rajveer 9051 
class markAlertsAsSeen_args:
9052 
  """
9053 
  Attributes:
9054 
   - warehouseId
9055 
  """
9056 
 
9057 
  thrift_spec = (
9058 
    None, # 0
9059 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9060 
  )
9061 
 
9062 
  def __init__(self, warehouseId=None,):
9063 
    self.warehouseId = warehouseId
9064 
 
9065 
  def read(self, iprot):
9066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9068 
      return
9069 
    iprot.readStructBegin()
9070 
    while True:
9071 
      (fname, ftype, fid) = iprot.readFieldBegin()
9072 
      if ftype == TType.STOP:
9073 
        break
9074 
      if fid == 1:
9075 
        if ftype == TType.I64:
9076 
          self.warehouseId = iprot.readI64();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      else:
9080 
        iprot.skip(ftype)
9081 
      iprot.readFieldEnd()
9082 
    iprot.readStructEnd()
9083 
 
9084 
  def write(self, oprot):
9085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9087 
      return
9088 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9089 
    if self.warehouseId is not None:
9090 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9091 
      oprot.writeI64(self.warehouseId)
9092 
      oprot.writeFieldEnd()
9093 
    oprot.writeFieldStop()
9094 
    oprot.writeStructEnd()
9095 
 
9096 
  def validate(self):
9097 
    return
9098 
 
9099 
 
9100 
  def __repr__(self):
9101 
    L = ['%s=%r' % (key, value)
9102 
      for key, value in self.__dict__.iteritems()]
9103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9104 
 
9105 
  def __eq__(self, other):
9106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9107 
 
9108 
  def __ne__(self, other):
9109 
    return not (self == other)
9110 
 
9111 
class markAlertsAsSeen_result:
9112 
 
9113 
  thrift_spec = (
9114 
  )
9115 
 
9116 
  def read(self, iprot):
9117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9119 
      return
9120 
    iprot.readStructBegin()
9121 
    while True:
9122 
      (fname, ftype, fid) = iprot.readFieldBegin()
9123 
      if ftype == TType.STOP:
9124 
        break
9125 
      else:
9126 
        iprot.skip(ftype)
9127 
      iprot.readFieldEnd()
9128 
    iprot.readStructEnd()
9129 
 
9130 
  def write(self, oprot):
9131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9133 
      return
9134 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9135 
    oprot.writeFieldStop()
9136 
    oprot.writeStructEnd()
9137 
 
9138 
  def validate(self):
9139 
    return
9140 
 
9141 
 
9142 
  def __repr__(self):
9143 
    L = ['%s=%r' % (key, value)
9144 
      for key, value in self.__dict__.iteritems()]
9145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9146 
 
9147 
  def __eq__(self, other):
9148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9149 
 
9150 
  def __ne__(self, other):
9151 
    return not (self == other)
9152 
 
3064 chandransh 9153 
class getValidOrderCount_args:
9154 
 
9155 
  thrift_spec = (
9156 
  )
9157 
 
9158 
  def read(self, iprot):
9159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9161 
      return
9162 
    iprot.readStructBegin()
9163 
    while True:
9164 
      (fname, ftype, fid) = iprot.readFieldBegin()
9165 
      if ftype == TType.STOP:
9166 
        break
9167 
      else:
9168 
        iprot.skip(ftype)
9169 
      iprot.readFieldEnd()
9170 
    iprot.readStructEnd()
9171 
 
9172 
  def write(self, oprot):
9173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9175 
      return
9176 
    oprot.writeStructBegin('getValidOrderCount_args')
9177 
    oprot.writeFieldStop()
9178 
    oprot.writeStructEnd()
9179 
 
3431 rajveer 9180 
  def validate(self):
9181 
    return
9182 
 
9183 
 
3064 chandransh 9184 
  def __repr__(self):
9185 
    L = ['%s=%r' % (key, value)
9186 
      for key, value in self.__dict__.iteritems()]
9187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9188 
 
9189 
  def __eq__(self, other):
9190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9191 
 
9192 
  def __ne__(self, other):
9193 
    return not (self == other)
9194 
 
9195 
class getValidOrderCount_result:
94 ashish 9196 
  """
9197 
  Attributes:
9198 
   - success
9199 
  """
9200 
 
9201 
  thrift_spec = (
3064 chandransh 9202 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9203 
  )
9204 
 
3064 chandransh 9205 
  def __init__(self, success=None,):
94 ashish 9206 
    self.success = success
9207 
 
9208 
  def read(self, iprot):
9209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9211 
      return
9212 
    iprot.readStructBegin()
9213 
    while True:
9214 
      (fname, ftype, fid) = iprot.readFieldBegin()
9215 
      if ftype == TType.STOP:
9216 
        break
9217 
      if fid == 0:
3064 chandransh 9218 
        if ftype == TType.I64:
9219 
          self.success = iprot.readI64();
94 ashish 9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      else:
9223 
        iprot.skip(ftype)
9224 
      iprot.readFieldEnd()
9225 
    iprot.readStructEnd()
9226 
 
9227 
  def write(self, oprot):
9228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9230 
      return
3064 chandransh 9231 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9232 
    if self.success is not None:
3064 chandransh 9233 
      oprot.writeFieldBegin('success', TType.I64, 0)
9234 
      oprot.writeI64(self.success)
94 ashish 9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
3431 rajveer 9239 
  def validate(self):
9240 
    return
9241 
 
9242 
 
94 ashish 9243 
  def __repr__(self):
9244 
    L = ['%s=%r' % (key, value)
9245 
      for key, value in self.__dict__.iteritems()]
9246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9247 
 
9248 
  def __eq__(self, other):
9249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9250 
 
9251 
  def __ne__(self, other):
9252 
    return not (self == other)
9253 
 
3064 chandransh 9254 
class getNoOfCustomersWithSuccessfulTransaction_args:
9255 
 
9256 
  thrift_spec = (
9257 
  )
9258 
 
9259 
  def read(self, iprot):
9260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9262 
      return
9263 
    iprot.readStructBegin()
9264 
    while True:
9265 
      (fname, ftype, fid) = iprot.readFieldBegin()
9266 
      if ftype == TType.STOP:
9267 
        break
9268 
      else:
9269 
        iprot.skip(ftype)
9270 
      iprot.readFieldEnd()
9271 
    iprot.readStructEnd()
9272 
 
9273 
  def write(self, oprot):
9274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9276 
      return
9277 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9278 
    oprot.writeFieldStop()
9279 
    oprot.writeStructEnd()
9280 
 
3431 rajveer 9281 
  def validate(self):
9282 
    return
9283 
 
9284 
 
3064 chandransh 9285 
  def __repr__(self):
9286 
    L = ['%s=%r' % (key, value)
9287 
      for key, value in self.__dict__.iteritems()]
9288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9289 
 
9290 
  def __eq__(self, other):
9291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9292 
 
9293 
  def __ne__(self, other):
9294 
    return not (self == other)
9295 
 
9296 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9297 
  """
9298 
  Attributes:
3064 chandransh 9299 
   - success
94 ashish 9300 
  """
9301 
 
9302 
  thrift_spec = (
3064 chandransh 9303 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9304 
  )
9305 
 
3064 chandransh 9306 
  def __init__(self, success=None,):
9307 
    self.success = success
94 ashish 9308 
 
9309 
  def read(self, iprot):
9310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9312 
      return
9313 
    iprot.readStructBegin()
9314 
    while True:
9315 
      (fname, ftype, fid) = iprot.readFieldBegin()
9316 
      if ftype == TType.STOP:
9317 
        break
3064 chandransh 9318 
      if fid == 0:
94 ashish 9319 
        if ftype == TType.I64:
3064 chandransh 9320 
          self.success = iprot.readI64();
94 ashish 9321 
        else:
9322 
          iprot.skip(ftype)
9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
3064 chandransh 9332 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9333 
    if self.success is not None:
3064 chandransh 9334 
      oprot.writeFieldBegin('success', TType.I64, 0)
9335 
      oprot.writeI64(self.success)
94 ashish 9336 
      oprot.writeFieldEnd()
9337 
    oprot.writeFieldStop()
9338 
    oprot.writeStructEnd()
9339 
 
3431 rajveer 9340 
  def validate(self):
9341 
    return
9342 
 
9343 
 
94 ashish 9344 
  def __repr__(self):
9345 
    L = ['%s=%r' % (key, value)
9346 
      for key, value in self.__dict__.iteritems()]
9347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9348 
 
9349 
  def __eq__(self, other):
9350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9351 
 
9352 
  def __ne__(self, other):
9353 
    return not (self == other)
9354 
 
3064 chandransh 9355 
class getValidOrdersAmountRange_args:
9356 
 
9357 
  thrift_spec = (
9358 
  )
9359 
 
9360 
  def read(self, iprot):
9361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9363 
      return
9364 
    iprot.readStructBegin()
9365 
    while True:
9366 
      (fname, ftype, fid) = iprot.readFieldBegin()
9367 
      if ftype == TType.STOP:
9368 
        break
9369 
      else:
9370 
        iprot.skip(ftype)
9371 
      iprot.readFieldEnd()
9372 
    iprot.readStructEnd()
9373 
 
9374 
  def write(self, oprot):
9375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9377 
      return
9378 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9379 
    oprot.writeFieldStop()
9380 
    oprot.writeStructEnd()
9381 
 
3431 rajveer 9382 
  def validate(self):
9383 
    return
9384 
 
9385 
 
3064 chandransh 9386 
  def __repr__(self):
9387 
    L = ['%s=%r' % (key, value)
9388 
      for key, value in self.__dict__.iteritems()]
9389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9390 
 
9391 
  def __eq__(self, other):
9392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9393 
 
9394 
  def __ne__(self, other):
9395 
    return not (self == other)
9396 
 
9397 
class getValidOrdersAmountRange_result:
94 ashish 9398 
  """
9399 
  Attributes:
9400 
   - success
9401 
  """
9402 
 
9403 
  thrift_spec = (
3064 chandransh 9404 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9405 
  )
9406 
 
3064 chandransh 9407 
  def __init__(self, success=None,):
94 ashish 9408 
    self.success = success
9409 
 
9410 
  def read(self, iprot):
9411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9413 
      return
9414 
    iprot.readStructBegin()
9415 
    while True:
9416 
      (fname, ftype, fid) = iprot.readFieldBegin()
9417 
      if ftype == TType.STOP:
9418 
        break
9419 
      if fid == 0:
483 rajveer 9420 
        if ftype == TType.LIST:
9421 
          self.success = []
4133 chandransh 9422 
          (_etype122, _size119) = iprot.readListBegin()
9423 
          for _i123 in xrange(_size119):
9424 
            _elem124 = iprot.readDouble();
9425 
            self.success.append(_elem124)
483 rajveer 9426 
          iprot.readListEnd()
94 ashish 9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
3064 chandransh 9438 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9439 
    if self.success is not None:
483 rajveer 9440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9441 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9442 
      for iter125 in self.success:
9443 
        oprot.writeDouble(iter125)
483 rajveer 9444 
      oprot.writeListEnd()
94 ashish 9445 
      oprot.writeFieldEnd()
9446 
    oprot.writeFieldStop()
9447 
    oprot.writeStructEnd()
9448 
 
3431 rajveer 9449 
  def validate(self):
9450 
    return
9451 
 
9452 
 
94 ashish 9453 
  def __repr__(self):
9454 
    L = ['%s=%r' % (key, value)
9455 
      for key, value in self.__dict__.iteritems()]
9456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9457 
 
9458 
  def __eq__(self, other):
9459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9460 
 
9461 
  def __ne__(self, other):
9462 
    return not (self == other)
9463 
 
3064 chandransh 9464 
class getValidOrders_args:
1528 ankur.sing 9465 
  """
9466 
  Attributes:
3064 chandransh 9467 
   - limit
1528 ankur.sing 9468 
  """
9469 
 
9470 
  thrift_spec = (
9471 
    None, # 0
3064 chandransh 9472 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9473 
  )
9474 
 
3064 chandransh 9475 
  def __init__(self, limit=None,):
9476 
    self.limit = limit
1528 ankur.sing 9477 
 
9478 
  def read(self, iprot):
9479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9481 
      return
9482 
    iprot.readStructBegin()
9483 
    while True:
9484 
      (fname, ftype, fid) = iprot.readFieldBegin()
9485 
      if ftype == TType.STOP:
9486 
        break
9487 
      if fid == 1:
9488 
        if ftype == TType.I64:
3064 chandransh 9489 
          self.limit = iprot.readI64();
1528 ankur.sing 9490 
        else:
9491 
          iprot.skip(ftype)
9492 
      else:
9493 
        iprot.skip(ftype)
9494 
      iprot.readFieldEnd()
9495 
    iprot.readStructEnd()
9496 
 
9497 
  def write(self, oprot):
9498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9500 
      return
3064 chandransh 9501 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9502 
    if self.limit is not None:
3064 chandransh 9503 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9504 
      oprot.writeI64(self.limit)
1528 ankur.sing 9505 
      oprot.writeFieldEnd()
9506 
    oprot.writeFieldStop()
9507 
    oprot.writeStructEnd()
9508 
 
3431 rajveer 9509 
  def validate(self):
9510 
    return
9511 
 
9512 
 
1528 ankur.sing 9513 
  def __repr__(self):
9514 
    L = ['%s=%r' % (key, value)
9515 
      for key, value in self.__dict__.iteritems()]
9516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9517 
 
9518 
  def __eq__(self, other):
9519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9520 
 
9521 
  def __ne__(self, other):
9522 
    return not (self == other)
9523 
 
3064 chandransh 9524 
class getValidOrders_result:
1528 ankur.sing 9525 
  """
9526 
  Attributes:
9527 
   - success
9528 
  """
9529 
 
9530 
  thrift_spec = (
3064 chandransh 9531 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9532 
  )
9533 
 
3064 chandransh 9534 
  def __init__(self, success=None,):
1528 ankur.sing 9535 
    self.success = success
9536 
 
9537 
  def read(self, iprot):
9538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9540 
      return
9541 
    iprot.readStructBegin()
9542 
    while True:
9543 
      (fname, ftype, fid) = iprot.readFieldBegin()
9544 
      if ftype == TType.STOP:
9545 
        break
9546 
      if fid == 0:
3064 chandransh 9547 
        if ftype == TType.LIST:
9548 
          self.success = []
4133 chandransh 9549 
          (_etype129, _size126) = iprot.readListBegin()
9550 
          for _i130 in xrange(_size126):
9551 
            _elem131 = Order()
9552 
            _elem131.read(iprot)
9553 
            self.success.append(_elem131)
3064 chandransh 9554 
          iprot.readListEnd()
1528 ankur.sing 9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      else:
9558 
        iprot.skip(ftype)
9559 
      iprot.readFieldEnd()
9560 
    iprot.readStructEnd()
9561 
 
9562 
  def write(self, oprot):
9563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9565 
      return
3064 chandransh 9566 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9567 
    if self.success is not None:
3064 chandransh 9568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9569 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9570 
      for iter132 in self.success:
9571 
        iter132.write(oprot)
3064 chandransh 9572 
      oprot.writeListEnd()
1528 ankur.sing 9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
3431 rajveer 9577 
  def validate(self):
9578 
    return
9579 
 
9580 
 
1528 ankur.sing 9581 
  def __repr__(self):
9582 
    L = ['%s=%r' % (key, value)
9583 
      for key, value in self.__dict__.iteritems()]
9584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9585 
 
9586 
  def __eq__(self, other):
9587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9588 
 
9589 
  def __ne__(self, other):
9590 
    return not (self == other)
9591 
 
1220 chandransh 9592 
class batchOrders_args:
9593 
  """
9594 
  Attributes:
9595 
   - warehouseId
9596 
  """
9597 
 
9598 
  thrift_spec = (
9599 
    None, # 0
9600 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9601 
  )
9602 
 
9603 
  def __init__(self, warehouseId=None,):
9604 
    self.warehouseId = warehouseId
9605 
 
9606 
  def read(self, iprot):
9607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9609 
      return
9610 
    iprot.readStructBegin()
9611 
    while True:
9612 
      (fname, ftype, fid) = iprot.readFieldBegin()
9613 
      if ftype == TType.STOP:
9614 
        break
9615 
      if fid == 1:
9616 
        if ftype == TType.I64:
9617 
          self.warehouseId = iprot.readI64();
9618 
        else:
9619 
          iprot.skip(ftype)
9620 
      else:
9621 
        iprot.skip(ftype)
9622 
      iprot.readFieldEnd()
9623 
    iprot.readStructEnd()
9624 
 
9625 
  def write(self, oprot):
9626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9628 
      return
9629 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9630 
    if self.warehouseId is not None:
1220 chandransh 9631 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9632 
      oprot.writeI64(self.warehouseId)
9633 
      oprot.writeFieldEnd()
9634 
    oprot.writeFieldStop()
9635 
    oprot.writeStructEnd()
9636 
 
3431 rajveer 9637 
  def validate(self):
9638 
    return
9639 
 
9640 
 
1220 chandransh 9641 
  def __repr__(self):
9642 
    L = ['%s=%r' % (key, value)
9643 
      for key, value in self.__dict__.iteritems()]
9644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9645 
 
9646 
  def __eq__(self, other):
9647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9648 
 
9649 
  def __ne__(self, other):
9650 
    return not (self == other)
9651 
 
9652 
class batchOrders_result:
9653 
  """
9654 
  Attributes:
9655 
   - success
9656 
   - ex
9657 
  """
9658 
 
9659 
  thrift_spec = (
9660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9662 
  )
9663 
 
9664 
  def __init__(self, success=None, ex=None,):
9665 
    self.success = success
9666 
    self.ex = ex
9667 
 
9668 
  def read(self, iprot):
9669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9671 
      return
9672 
    iprot.readStructBegin()
9673 
    while True:
9674 
      (fname, ftype, fid) = iprot.readFieldBegin()
9675 
      if ftype == TType.STOP:
9676 
        break
9677 
      if fid == 0:
9678 
        if ftype == TType.LIST:
9679 
          self.success = []
4133 chandransh 9680 
          (_etype136, _size133) = iprot.readListBegin()
9681 
          for _i137 in xrange(_size133):
9682 
            _elem138 = Order()
9683 
            _elem138.read(iprot)
9684 
            self.success.append(_elem138)
1220 chandransh 9685 
          iprot.readListEnd()
9686 
        else:
9687 
          iprot.skip(ftype)
9688 
      elif fid == 1:
9689 
        if ftype == TType.STRUCT:
9690 
          self.ex = TransactionServiceException()
9691 
          self.ex.read(iprot)
9692 
        else:
9693 
          iprot.skip(ftype)
9694 
      else:
9695 
        iprot.skip(ftype)
9696 
      iprot.readFieldEnd()
9697 
    iprot.readStructEnd()
9698 
 
9699 
  def write(self, oprot):
9700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9702 
      return
9703 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9704 
    if self.success is not None:
1220 chandransh 9705 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9706 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9707 
      for iter139 in self.success:
9708 
        iter139.write(oprot)
1220 chandransh 9709 
      oprot.writeListEnd()
9710 
      oprot.writeFieldEnd()
3431 rajveer 9711 
    if self.ex is not None:
1220 chandransh 9712 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9713 
      self.ex.write(oprot)
9714 
      oprot.writeFieldEnd()
9715 
    oprot.writeFieldStop()
9716 
    oprot.writeStructEnd()
9717 
 
3431 rajveer 9718 
  def validate(self):
9719 
    return
9720 
 
9721 
 
1220 chandransh 9722 
  def __repr__(self):
9723 
    L = ['%s=%r' % (key, value)
9724 
      for key, value in self.__dict__.iteritems()]
9725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9726 
 
9727 
  def __eq__(self, other):
9728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9729 
 
9730 
  def __ne__(self, other):
9731 
    return not (self == other)
9732 
 
1208 chandransh 9733 
class markOrderAsOutOfStock_args:
9734 
  """
9735 
  Attributes:
9736 
   - orderId
9737 
  """
9738 
 
9739 
  thrift_spec = (
9740 
    None, # 0
9741 
    (1, TType.I64, 'orderId', None, None, ), # 1
9742 
  )
9743 
 
9744 
  def __init__(self, orderId=None,):
9745 
    self.orderId = orderId
9746 
 
9747 
  def read(self, iprot):
9748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9750 
      return
9751 
    iprot.readStructBegin()
9752 
    while True:
9753 
      (fname, ftype, fid) = iprot.readFieldBegin()
9754 
      if ftype == TType.STOP:
9755 
        break
9756 
      if fid == 1:
9757 
        if ftype == TType.I64:
9758 
          self.orderId = iprot.readI64();
9759 
        else:
9760 
          iprot.skip(ftype)
9761 
      else:
9762 
        iprot.skip(ftype)
9763 
      iprot.readFieldEnd()
9764 
    iprot.readStructEnd()
9765 
 
9766 
  def write(self, oprot):
9767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9769 
      return
9770 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9771 
    if self.orderId is not None:
1208 chandransh 9772 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9773 
      oprot.writeI64(self.orderId)
9774 
      oprot.writeFieldEnd()
9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
3431 rajveer 9778 
  def validate(self):
9779 
    return
9780 
 
9781 
 
1208 chandransh 9782 
  def __repr__(self):
9783 
    L = ['%s=%r' % (key, value)
9784 
      for key, value in self.__dict__.iteritems()]
9785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9786 
 
9787 
  def __eq__(self, other):
9788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9789 
 
9790 
  def __ne__(self, other):
9791 
    return not (self == other)
9792 
 
9793 
class markOrderAsOutOfStock_result:
9794 
  """
9795 
  Attributes:
9796 
   - success
9797 
   - ex
9798 
  """
9799 
 
9800 
  thrift_spec = (
9801 
    (0, TType.BOOL, 'success', None, None, ), # 0
9802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9803 
  )
9804 
 
9805 
  def __init__(self, success=None, ex=None,):
9806 
    self.success = success
9807 
    self.ex = ex
9808 
 
9809 
  def read(self, iprot):
9810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9812 
      return
9813 
    iprot.readStructBegin()
9814 
    while True:
9815 
      (fname, ftype, fid) = iprot.readFieldBegin()
9816 
      if ftype == TType.STOP:
9817 
        break
9818 
      if fid == 0:
9819 
        if ftype == TType.BOOL:
9820 
          self.success = iprot.readBool();
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 1:
9824 
        if ftype == TType.STRUCT:
9825 
          self.ex = TransactionServiceException()
9826 
          self.ex.read(iprot)
9827 
        else:
9828 
          iprot.skip(ftype)
9829 
      else:
9830 
        iprot.skip(ftype)
9831 
      iprot.readFieldEnd()
9832 
    iprot.readStructEnd()
9833 
 
9834 
  def write(self, oprot):
9835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9837 
      return
9838 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9839 
    if self.success is not None:
1208 chandransh 9840 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9841 
      oprot.writeBool(self.success)
9842 
      oprot.writeFieldEnd()
3431 rajveer 9843 
    if self.ex is not None:
1208 chandransh 9844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9845 
      self.ex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
3431 rajveer 9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
1208 chandransh 9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
3064 chandransh 9865 
class verifyOrder_args:
759 chandransh 9866 
  """
9867 
  Attributes:
3064 chandransh 9868 
   - orderId
759 chandransh 9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
3064 chandransh 9873 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9874 
  )
9875 
 
3064 chandransh 9876 
  def __init__(self, orderId=None,):
9877 
    self.orderId = orderId
759 chandransh 9878 
 
9879 
  def read(self, iprot):
9880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9882 
      return
9883 
    iprot.readStructBegin()
9884 
    while True:
9885 
      (fname, ftype, fid) = iprot.readFieldBegin()
9886 
      if ftype == TType.STOP:
9887 
        break
9888 
      if fid == 1:
9889 
        if ftype == TType.I64:
3064 chandransh 9890 
          self.orderId = iprot.readI64();
759 chandransh 9891 
        else:
9892 
          iprot.skip(ftype)
9893 
      else:
9894 
        iprot.skip(ftype)
9895 
      iprot.readFieldEnd()
9896 
    iprot.readStructEnd()
9897 
 
9898 
  def write(self, oprot):
9899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9901 
      return
3064 chandransh 9902 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9903 
    if self.orderId is not None:
3064 chandransh 9904 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9905 
      oprot.writeI64(self.orderId)
759 chandransh 9906 
      oprot.writeFieldEnd()
9907 
    oprot.writeFieldStop()
9908 
    oprot.writeStructEnd()
9909 
 
3431 rajveer 9910 
  def validate(self):
9911 
    return
9912 
 
9913 
 
759 chandransh 9914 
  def __repr__(self):
9915 
    L = ['%s=%r' % (key, value)
9916 
      for key, value in self.__dict__.iteritems()]
9917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9918 
 
9919 
  def __eq__(self, other):
9920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9921 
 
9922 
  def __ne__(self, other):
9923 
    return not (self == other)
9924 
 
3064 chandransh 9925 
class verifyOrder_result:
759 chandransh 9926 
  """
9927 
  Attributes:
9928 
   - success
9929 
   - ex
9930 
  """
9931 
 
9932 
  thrift_spec = (
9933 
    (0, TType.BOOL, 'success', None, None, ), # 0
9934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9935 
  )
9936 
 
9937 
  def __init__(self, success=None, ex=None,):
9938 
    self.success = success
9939 
    self.ex = ex
9940 
 
9941 
  def read(self, iprot):
9942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9944 
      return
9945 
    iprot.readStructBegin()
9946 
    while True:
9947 
      (fname, ftype, fid) = iprot.readFieldBegin()
9948 
      if ftype == TType.STOP:
9949 
        break
9950 
      if fid == 0:
9951 
        if ftype == TType.BOOL:
9952 
          self.success = iprot.readBool();
9953 
        else:
9954 
          iprot.skip(ftype)
9955 
      elif fid == 1:
9956 
        if ftype == TType.STRUCT:
9957 
          self.ex = TransactionServiceException()
9958 
          self.ex.read(iprot)
9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      else:
9962 
        iprot.skip(ftype)
9963 
      iprot.readFieldEnd()
9964 
    iprot.readStructEnd()
9965 
 
9966 
  def write(self, oprot):
9967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9969 
      return
3064 chandransh 9970 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9971 
    if self.success is not None:
759 chandransh 9972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9973 
      oprot.writeBool(self.success)
9974 
      oprot.writeFieldEnd()
3431 rajveer 9975 
    if self.ex is not None:
759 chandransh 9976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9977 
      self.ex.write(oprot)
9978 
      oprot.writeFieldEnd()
9979 
    oprot.writeFieldStop()
9980 
    oprot.writeStructEnd()
9981 
 
3431 rajveer 9982 
  def validate(self):
9983 
    return
9984 
 
9985 
 
759 chandransh 9986 
  def __repr__(self):
9987 
    L = ['%s=%r' % (key, value)
9988 
      for key, value in self.__dict__.iteritems()]
9989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9990 
 
9991 
  def __eq__(self, other):
9992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9993 
 
9994 
  def __ne__(self, other):
9995 
    return not (self == other)
9996 
 
3064 chandransh 9997 
class acceptOrder_args:
1113 chandransh 9998 
  """
9999 
  Attributes:
3064 chandransh 10000 
   - orderId
1113 chandransh 10001 
  """
10002 
 
10003 
  thrift_spec = (
10004 
    None, # 0
3064 chandransh 10005 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10006 
  )
10007 
 
3064 chandransh 10008 
  def __init__(self, orderId=None,):
10009 
    self.orderId = orderId
1113 chandransh 10010 
 
10011 
  def read(self, iprot):
10012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10014 
      return
10015 
    iprot.readStructBegin()
10016 
    while True:
10017 
      (fname, ftype, fid) = iprot.readFieldBegin()
10018 
      if ftype == TType.STOP:
10019 
        break
10020 
      if fid == 1:
10021 
        if ftype == TType.I64:
3064 chandransh 10022 
          self.orderId = iprot.readI64();
1113 chandransh 10023 
        else:
10024 
          iprot.skip(ftype)
10025 
      else:
10026 
        iprot.skip(ftype)
10027 
      iprot.readFieldEnd()
10028 
    iprot.readStructEnd()
10029 
 
10030 
  def write(self, oprot):
10031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10033 
      return
3064 chandransh 10034 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10035 
    if self.orderId is not None:
3064 chandransh 10036 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10037 
      oprot.writeI64(self.orderId)
1113 chandransh 10038 
      oprot.writeFieldEnd()
10039 
    oprot.writeFieldStop()
10040 
    oprot.writeStructEnd()
10041 
 
3431 rajveer 10042 
  def validate(self):
10043 
    return
10044 
 
10045 
 
1113 chandransh 10046 
  def __repr__(self):
10047 
    L = ['%s=%r' % (key, value)
10048 
      for key, value in self.__dict__.iteritems()]
10049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10050 
 
10051 
  def __eq__(self, other):
10052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10053 
 
10054 
  def __ne__(self, other):
10055 
    return not (self == other)
10056 
 
3064 chandransh 10057 
class acceptOrder_result:
1113 chandransh 10058 
  """
10059 
  Attributes:
10060 
   - success
10061 
   - ex
10062 
  """
10063 
 
10064 
  thrift_spec = (
3064 chandransh 10065 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10067 
  )
10068 
 
10069 
  def __init__(self, success=None, ex=None,):
10070 
    self.success = success
10071 
    self.ex = ex
10072 
 
10073 
  def read(self, iprot):
10074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10076 
      return
10077 
    iprot.readStructBegin()
10078 
    while True:
10079 
      (fname, ftype, fid) = iprot.readFieldBegin()
10080 
      if ftype == TType.STOP:
10081 
        break
10082 
      if fid == 0:
3064 chandransh 10083 
        if ftype == TType.BOOL:
10084 
          self.success = iprot.readBool();
1113 chandransh 10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 1:
10088 
        if ftype == TType.STRUCT:
10089 
          self.ex = TransactionServiceException()
10090 
          self.ex.read(iprot)
10091 
        else:
10092 
          iprot.skip(ftype)
10093 
      else:
10094 
        iprot.skip(ftype)
10095 
      iprot.readFieldEnd()
10096 
    iprot.readStructEnd()
10097 
 
10098 
  def write(self, oprot):
10099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10101 
      return
3064 chandransh 10102 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10103 
    if self.success is not None:
3064 chandransh 10104 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10105 
      oprot.writeBool(self.success)
1113 chandransh 10106 
      oprot.writeFieldEnd()
3431 rajveer 10107 
    if self.ex is not None:
1113 chandransh 10108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10109 
      self.ex.write(oprot)
10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
3431 rajveer 10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
1113 chandransh 10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
3064 chandransh 10129 
class addBillingDetails_args:
1135 chandransh 10130 
  """
10131 
  Attributes:
3064 chandransh 10132 
   - orderId
10133 
   - invoice_number
4658 mandeep.dh 10134 
   - serialNumber
4283 anupam.sin 10135 
   - itemNumber
3064 chandransh 10136 
   - billed_by
4264 rajveer 10137 
   - jacketNumber
4283 anupam.sin 10138 
   - billingType
10139 
   - vendorId
1135 chandransh 10140 
  """
10141 
 
10142 
  thrift_spec = (
10143 
    None, # 0
3064 chandransh 10144 
    (1, TType.I64, 'orderId', None, None, ), # 1
10145 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10146 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10147 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10148 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10149 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10150 
    (7, TType.I64, 'billingType', None, None, ), # 7
10151 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10152 
  )
10153 
 
4658 mandeep.dh 10154 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10155 
    self.orderId = orderId
10156 
    self.invoice_number = invoice_number
4658 mandeep.dh 10157 
    self.serialNumber = serialNumber
4283 anupam.sin 10158 
    self.itemNumber = itemNumber
3064 chandransh 10159 
    self.billed_by = billed_by
4264 rajveer 10160 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10161 
    self.billingType = billingType
10162 
    self.vendorId = vendorId
1135 chandransh 10163 
 
10164 
  def read(self, iprot):
10165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10167 
      return
10168 
    iprot.readStructBegin()
10169 
    while True:
10170 
      (fname, ftype, fid) = iprot.readFieldBegin()
10171 
      if ftype == TType.STOP:
10172 
        break
10173 
      if fid == 1:
10174 
        if ftype == TType.I64:
3064 chandransh 10175 
          self.orderId = iprot.readI64();
1135 chandransh 10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      elif fid == 2:
3064 chandransh 10179 
        if ftype == TType.STRING:
10180 
          self.invoice_number = iprot.readString();
1135 chandransh 10181 
        else:
10182 
          iprot.skip(ftype)
3064 chandransh 10183 
      elif fid == 3:
4658 mandeep.dh 10184 
        if ftype == TType.STRING:
10185 
          self.serialNumber = iprot.readString();
3064 chandransh 10186 
        else:
10187 
          iprot.skip(ftype)
10188 
      elif fid == 4:
10189 
        if ftype == TType.STRING:
10190 
          self.itemNumber = iprot.readString();
10191 
        else:
10192 
          iprot.skip(ftype)
10193 
      elif fid == 5:
10194 
        if ftype == TType.STRING:
4283 anupam.sin 10195 
          self.billed_by = iprot.readString();
3064 chandransh 10196 
        else:
10197 
          iprot.skip(ftype)
10198 
      elif fid == 6:
10199 
        if ftype == TType.I64:
4283 anupam.sin 10200 
          self.jacketNumber = iprot.readI64();
10201 
        else:
10202 
          iprot.skip(ftype)
10203 
      elif fid == 7:
10204 
        if ftype == TType.I64:
3064 chandransh 10205 
          self.billingType = iprot.readI64();
10206 
        else:
10207 
          iprot.skip(ftype)
4283 anupam.sin 10208 
      elif fid == 8:
10209 
        if ftype == TType.I64:
10210 
          self.vendorId = iprot.readI64();
10211 
        else:
10212 
          iprot.skip(ftype)
1246 chandransh 10213 
      else:
10214 
        iprot.skip(ftype)
10215 
      iprot.readFieldEnd()
10216 
    iprot.readStructEnd()
10217 
 
10218 
  def write(self, oprot):
10219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10221 
      return
4283 anupam.sin 10222 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10223 
    if self.orderId is not None:
3064 chandransh 10224 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10225 
      oprot.writeI64(self.orderId)
1246 chandransh 10226 
      oprot.writeFieldEnd()
4283 anupam.sin 10227 
    if self.invoice_number is not None:
10228 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10229 
      oprot.writeString(self.invoice_number)
1246 chandransh 10230 
      oprot.writeFieldEnd()
4658 mandeep.dh 10231 
    if self.serialNumber is not None:
10232 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10233 
      oprot.writeString(self.serialNumber)
3064 chandransh 10234 
      oprot.writeFieldEnd()
3431 rajveer 10235 
    if self.itemNumber is not None:
3064 chandransh 10236 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10237 
      oprot.writeString(self.itemNumber)
10238 
      oprot.writeFieldEnd()
4283 anupam.sin 10239 
    if self.billed_by is not None:
10240 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10241 
      oprot.writeString(self.billed_by)
3064 chandransh 10242 
      oprot.writeFieldEnd()
4283 anupam.sin 10243 
    if self.jacketNumber is not None:
10244 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10245 
      oprot.writeI64(self.jacketNumber)
10246 
      oprot.writeFieldEnd()
3431 rajveer 10247 
    if self.billingType is not None:
4283 anupam.sin 10248 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10249 
      oprot.writeI64(self.billingType)
10250 
      oprot.writeFieldEnd()
4283 anupam.sin 10251 
    if self.vendorId is not None:
10252 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10253 
      oprot.writeI64(self.vendorId)
10254 
      oprot.writeFieldEnd()
1246 chandransh 10255 
    oprot.writeFieldStop()
10256 
    oprot.writeStructEnd()
10257 
 
3431 rajveer 10258 
  def validate(self):
10259 
    return
10260 
 
10261 
 
1246 chandransh 10262 
  def __repr__(self):
10263 
    L = ['%s=%r' % (key, value)
10264 
      for key, value in self.__dict__.iteritems()]
10265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10266 
 
10267 
  def __eq__(self, other):
10268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10269 
 
10270 
  def __ne__(self, other):
10271 
    return not (self == other)
10272 
 
4283 anupam.sin 10273 
class addBillingDetails_result:
1246 chandransh 10274 
  """
10275 
  Attributes:
3064 chandransh 10276 
   - success
1246 chandransh 10277 
   - ex
10278 
  """
10279 
 
10280 
  thrift_spec = (
3064 chandransh 10281 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10283 
  )
10284 
 
3064 chandransh 10285 
  def __init__(self, success=None, ex=None,):
10286 
    self.success = success
1246 chandransh 10287 
    self.ex = ex
10288 
 
10289 
  def read(self, iprot):
10290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10292 
      return
10293 
    iprot.readStructBegin()
10294 
    while True:
10295 
      (fname, ftype, fid) = iprot.readFieldBegin()
10296 
      if ftype == TType.STOP:
10297 
        break
3064 chandransh 10298 
      if fid == 0:
10299 
        if ftype == TType.BOOL:
10300 
          self.success = iprot.readBool();
10301 
        else:
10302 
          iprot.skip(ftype)
10303 
      elif fid == 1:
1246 chandransh 10304 
        if ftype == TType.STRUCT:
10305 
          self.ex = TransactionServiceException()
10306 
          self.ex.read(iprot)
10307 
        else:
10308 
          iprot.skip(ftype)
10309 
      else:
10310 
        iprot.skip(ftype)
10311 
      iprot.readFieldEnd()
10312 
    iprot.readStructEnd()
10313 
 
10314 
  def write(self, oprot):
10315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10317 
      return
4283 anupam.sin 10318 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10319 
    if self.success is not None:
3064 chandransh 10320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10321 
      oprot.writeBool(self.success)
10322 
      oprot.writeFieldEnd()
3431 rajveer 10323 
    if self.ex is not None:
1246 chandransh 10324 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10325 
      self.ex.write(oprot)
10326 
      oprot.writeFieldEnd()
10327 
    oprot.writeFieldStop()
10328 
    oprot.writeStructEnd()
10329 
 
3431 rajveer 10330 
  def validate(self):
10331 
    return
10332 
 
10333 
 
1246 chandransh 10334 
  def __repr__(self):
10335 
    L = ['%s=%r' % (key, value)
10336 
      for key, value in self.__dict__.iteritems()]
10337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10338 
 
10339 
  def __eq__(self, other):
10340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10341 
 
10342 
  def __ne__(self, other):
10343 
    return not (self == other)
10344 
 
4579 rajveer 10345 
class addInvoiceNumber_args:
10346 
  """
10347 
  Attributes:
10348 
   - orderId
10349 
   - invoiceNumber
10350 
  """
10351 
 
10352 
  thrift_spec = (
10353 
    None, # 0
10354 
    (1, TType.I64, 'orderId', None, None, ), # 1
10355 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10356 
  )
10357 
 
10358 
  def __init__(self, orderId=None, invoiceNumber=None,):
10359 
    self.orderId = orderId
10360 
    self.invoiceNumber = invoiceNumber
10361 
 
10362 
  def read(self, iprot):
10363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10365 
      return
10366 
    iprot.readStructBegin()
10367 
    while True:
10368 
      (fname, ftype, fid) = iprot.readFieldBegin()
10369 
      if ftype == TType.STOP:
10370 
        break
10371 
      if fid == 1:
10372 
        if ftype == TType.I64:
10373 
          self.orderId = iprot.readI64();
10374 
        else:
10375 
          iprot.skip(ftype)
10376 
      elif fid == 2:
10377 
        if ftype == TType.STRING:
10378 
          self.invoiceNumber = iprot.readString();
10379 
        else:
10380 
          iprot.skip(ftype)
10381 
      else:
10382 
        iprot.skip(ftype)
10383 
      iprot.readFieldEnd()
10384 
    iprot.readStructEnd()
10385 
 
10386 
  def write(self, oprot):
10387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10389 
      return
10390 
    oprot.writeStructBegin('addInvoiceNumber_args')
10391 
    if self.orderId is not None:
10392 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10393 
      oprot.writeI64(self.orderId)
10394 
      oprot.writeFieldEnd()
10395 
    if self.invoiceNumber is not None:
10396 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10397 
      oprot.writeString(self.invoiceNumber)
10398 
      oprot.writeFieldEnd()
10399 
    oprot.writeFieldStop()
10400 
    oprot.writeStructEnd()
10401 
 
10402 
  def validate(self):
10403 
    return
10404 
 
10405 
 
10406 
  def __repr__(self):
10407 
    L = ['%s=%r' % (key, value)
10408 
      for key, value in self.__dict__.iteritems()]
10409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10410 
 
10411 
  def __eq__(self, other):
10412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10413 
 
10414 
  def __ne__(self, other):
10415 
    return not (self == other)
10416 
 
10417 
class addInvoiceNumber_result:
10418 
  """
10419 
  Attributes:
10420 
   - ex
10421 
  """
10422 
 
10423 
  thrift_spec = (
10424 
    None, # 0
10425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10426 
  )
10427 
 
10428 
  def __init__(self, ex=None,):
10429 
    self.ex = ex
10430 
 
10431 
  def read(self, iprot):
10432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10434 
      return
10435 
    iprot.readStructBegin()
10436 
    while True:
10437 
      (fname, ftype, fid) = iprot.readFieldBegin()
10438 
      if ftype == TType.STOP:
10439 
        break
10440 
      if fid == 1:
10441 
        if ftype == TType.STRUCT:
10442 
          self.ex = TransactionServiceException()
10443 
          self.ex.read(iprot)
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      else:
10447 
        iprot.skip(ftype)
10448 
      iprot.readFieldEnd()
10449 
    iprot.readStructEnd()
10450 
 
10451 
  def write(self, oprot):
10452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10454 
      return
10455 
    oprot.writeStructBegin('addInvoiceNumber_result')
10456 
    if self.ex is not None:
10457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10458 
      self.ex.write(oprot)
10459 
      oprot.writeFieldEnd()
10460 
    oprot.writeFieldStop()
10461 
    oprot.writeStructEnd()
10462 
 
10463 
  def validate(self):
10464 
    return
10465 
 
10466 
 
10467 
  def __repr__(self):
10468 
    L = ['%s=%r' % (key, value)
10469 
      for key, value in self.__dict__.iteritems()]
10470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10471 
 
10472 
  def __eq__(self, other):
10473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10474 
 
10475 
  def __ne__(self, other):
10476 
    return not (self == other)
10477 
 
3064 chandransh 10478 
class markOrdersAsManifested_args:
1408 ankur.sing 10479 
  """
10480 
  Attributes:
3064 chandransh 10481 
   - warehouseId
1408 ankur.sing 10482 
   - providerId
3064 chandransh 10483 
   - cod
1408 ankur.sing 10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    None, # 0
3064 chandransh 10488 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10489 
    (2, TType.I64, 'providerId', None, None, ), # 2
10490 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10491 
  )
10492 
 
3064 chandransh 10493 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10494 
    self.warehouseId = warehouseId
1408 ankur.sing 10495 
    self.providerId = providerId
3064 chandransh 10496 
    self.cod = cod
1408 ankur.sing 10497 
 
10498 
  def read(self, iprot):
10499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10501 
      return
10502 
    iprot.readStructBegin()
10503 
    while True:
10504 
      (fname, ftype, fid) = iprot.readFieldBegin()
10505 
      if ftype == TType.STOP:
10506 
        break
10507 
      if fid == 1:
10508 
        if ftype == TType.I64:
3064 chandransh 10509 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10510 
        else:
10511 
          iprot.skip(ftype)
10512 
      elif fid == 2:
10513 
        if ftype == TType.I64:
3064 chandransh 10514 
          self.providerId = iprot.readI64();
1408 ankur.sing 10515 
        else:
10516 
          iprot.skip(ftype)
3064 chandransh 10517 
      elif fid == 3:
10518 
        if ftype == TType.BOOL:
10519 
          self.cod = iprot.readBool();
10520 
        else:
10521 
          iprot.skip(ftype)
1408 ankur.sing 10522 
      else:
10523 
        iprot.skip(ftype)
10524 
      iprot.readFieldEnd()
10525 
    iprot.readStructEnd()
10526 
 
10527 
  def write(self, oprot):
10528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10530 
      return
3064 chandransh 10531 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10532 
    if self.warehouseId is not None:
3064 chandransh 10533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10534 
      oprot.writeI64(self.warehouseId)
10535 
      oprot.writeFieldEnd()
3431 rajveer 10536 
    if self.providerId is not None:
3064 chandransh 10537 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10538 
      oprot.writeI64(self.providerId)
10539 
      oprot.writeFieldEnd()
3431 rajveer 10540 
    if self.cod is not None:
3064 chandransh 10541 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10542 
      oprot.writeBool(self.cod)
1408 ankur.sing 10543 
      oprot.writeFieldEnd()
10544 
    oprot.writeFieldStop()
10545 
    oprot.writeStructEnd()
10546 
 
3431 rajveer 10547 
  def validate(self):
10548 
    return
10549 
 
10550 
 
1408 ankur.sing 10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
3064 chandransh 10562 
class markOrdersAsManifested_result:
1408 ankur.sing 10563 
  """
10564 
  Attributes:
10565 
   - success
3064 chandransh 10566 
   - ex
1408 ankur.sing 10567 
  """
10568 
 
10569 
  thrift_spec = (
3064 chandransh 10570 
    (0, TType.BOOL, 'success', None, None, ), # 0
10571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10572 
  )
10573 
 
3064 chandransh 10574 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10575 
    self.success = success
3064 chandransh 10576 
    self.ex = ex
1408 ankur.sing 10577 
 
10578 
  def read(self, iprot):
10579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10581 
      return
10582 
    iprot.readStructBegin()
10583 
    while True:
10584 
      (fname, ftype, fid) = iprot.readFieldBegin()
10585 
      if ftype == TType.STOP:
10586 
        break
10587 
      if fid == 0:
3064 chandransh 10588 
        if ftype == TType.BOOL:
10589 
          self.success = iprot.readBool();
1408 ankur.sing 10590 
        else:
10591 
          iprot.skip(ftype)
3064 chandransh 10592 
      elif fid == 1:
10593 
        if ftype == TType.STRUCT:
10594 
          self.ex = TransactionServiceException()
10595 
          self.ex.read(iprot)
10596 
        else:
10597 
          iprot.skip(ftype)
1408 ankur.sing 10598 
      else:
10599 
        iprot.skip(ftype)
10600 
      iprot.readFieldEnd()
10601 
    iprot.readStructEnd()
10602 
 
10603 
  def write(self, oprot):
10604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10606 
      return
3064 chandransh 10607 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10608 
    if self.success is not None:
3064 chandransh 10609 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10610 
      oprot.writeBool(self.success)
1408 ankur.sing 10611 
      oprot.writeFieldEnd()
3431 rajveer 10612 
    if self.ex is not None:
3064 chandransh 10613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10614 
      self.ex.write(oprot)
10615 
      oprot.writeFieldEnd()
1408 ankur.sing 10616 
    oprot.writeFieldStop()
10617 
    oprot.writeStructEnd()
10618 
 
3431 rajveer 10619 
  def validate(self):
10620 
    return
10621 
 
10622 
 
1408 ankur.sing 10623 
  def __repr__(self):
10624 
    L = ['%s=%r' % (key, value)
10625 
      for key, value in self.__dict__.iteritems()]
10626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10627 
 
10628 
  def __eq__(self, other):
10629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10630 
 
10631 
  def __ne__(self, other):
10632 
    return not (self == other)
10633 
 
4410 rajveer 10634 
class markOrdersAsShippedFromWarehouse_args:
10635 
  """
10636 
  Attributes:
10637 
   - warehouseId
10638 
   - providerId
10639 
   - cod
10640 
  """
10641 
 
10642 
  thrift_spec = (
10643 
    None, # 0
10644 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10645 
    (2, TType.I64, 'providerId', None, None, ), # 2
10646 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10647 
  )
10648 
 
10649 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10650 
    self.warehouseId = warehouseId
10651 
    self.providerId = providerId
10652 
    self.cod = cod
10653 
 
10654 
  def read(self, iprot):
10655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10657 
      return
10658 
    iprot.readStructBegin()
10659 
    while True:
10660 
      (fname, ftype, fid) = iprot.readFieldBegin()
10661 
      if ftype == TType.STOP:
10662 
        break
10663 
      if fid == 1:
10664 
        if ftype == TType.I64:
10665 
          self.warehouseId = iprot.readI64();
10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      elif fid == 2:
10669 
        if ftype == TType.I64:
10670 
          self.providerId = iprot.readI64();
10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      elif fid == 3:
10674 
        if ftype == TType.BOOL:
10675 
          self.cod = iprot.readBool();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      else:
10679 
        iprot.skip(ftype)
10680 
      iprot.readFieldEnd()
10681 
    iprot.readStructEnd()
10682 
 
10683 
  def write(self, oprot):
10684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10686 
      return
10687 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10688 
    if self.warehouseId is not None:
10689 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10690 
      oprot.writeI64(self.warehouseId)
10691 
      oprot.writeFieldEnd()
10692 
    if self.providerId is not None:
10693 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10694 
      oprot.writeI64(self.providerId)
10695 
      oprot.writeFieldEnd()
10696 
    if self.cod is not None:
10697 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10698 
      oprot.writeBool(self.cod)
10699 
      oprot.writeFieldEnd()
10700 
    oprot.writeFieldStop()
10701 
    oprot.writeStructEnd()
10702 
 
10703 
  def validate(self):
10704 
    return
10705 
 
10706 
 
10707 
  def __repr__(self):
10708 
    L = ['%s=%r' % (key, value)
10709 
      for key, value in self.__dict__.iteritems()]
10710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10711 
 
10712 
  def __eq__(self, other):
10713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10714 
 
10715 
  def __ne__(self, other):
10716 
    return not (self == other)
10717 
 
10718 
class markOrdersAsShippedFromWarehouse_result:
10719 
  """
10720 
  Attributes:
10721 
   - success
10722 
   - ex
10723 
  """
10724 
 
10725 
  thrift_spec = (
10726 
    (0, TType.BOOL, 'success', None, None, ), # 0
10727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10728 
  )
10729 
 
10730 
  def __init__(self, success=None, ex=None,):
10731 
    self.success = success
10732 
    self.ex = ex
10733 
 
10734 
  def read(self, iprot):
10735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10737 
      return
10738 
    iprot.readStructBegin()
10739 
    while True:
10740 
      (fname, ftype, fid) = iprot.readFieldBegin()
10741 
      if ftype == TType.STOP:
10742 
        break
10743 
      if fid == 0:
10744 
        if ftype == TType.BOOL:
10745 
          self.success = iprot.readBool();
10746 
        else:
10747 
          iprot.skip(ftype)
10748 
      elif fid == 1:
10749 
        if ftype == TType.STRUCT:
10750 
          self.ex = TransactionServiceException()
10751 
          self.ex.read(iprot)
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      else:
10755 
        iprot.skip(ftype)
10756 
      iprot.readFieldEnd()
10757 
    iprot.readStructEnd()
10758 
 
10759 
  def write(self, oprot):
10760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10762 
      return
10763 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10764 
    if self.success is not None:
10765 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10766 
      oprot.writeBool(self.success)
10767 
      oprot.writeFieldEnd()
10768 
    if self.ex is not None:
10769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10770 
      self.ex.write(oprot)
10771 
      oprot.writeFieldEnd()
10772 
    oprot.writeFieldStop()
10773 
    oprot.writeStructEnd()
10774 
 
10775 
  def validate(self):
10776 
    return
10777 
 
10778 
 
10779 
  def __repr__(self):
10780 
    L = ['%s=%r' % (key, value)
10781 
      for key, value in self.__dict__.iteritems()]
10782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10783 
 
10784 
  def __eq__(self, other):
10785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10786 
 
10787 
  def __ne__(self, other):
10788 
    return not (self == other)
10789 
 
3064 chandransh 10790 
class markOrdersAsPickedUp_args:
304 ashish 10791 
  """
10792 
  Attributes:
3064 chandransh 10793 
   - providerId
10794 
   - pickupDetails
304 ashish 10795 
  """
94 ashish 10796 
 
304 ashish 10797 
  thrift_spec = (
10798 
    None, # 0
3064 chandransh 10799 
    (1, TType.I64, 'providerId', None, None, ), # 1
10800 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10801 
  )
10802 
 
3064 chandransh 10803 
  def __init__(self, providerId=None, pickupDetails=None,):
10804 
    self.providerId = providerId
10805 
    self.pickupDetails = pickupDetails
304 ashish 10806 
 
10807 
  def read(self, iprot):
10808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10810 
      return
10811 
    iprot.readStructBegin()
10812 
    while True:
10813 
      (fname, ftype, fid) = iprot.readFieldBegin()
10814 
      if ftype == TType.STOP:
10815 
        break
10816 
      if fid == 1:
10817 
        if ftype == TType.I64:
3064 chandransh 10818 
          self.providerId = iprot.readI64();
304 ashish 10819 
        else:
10820 
          iprot.skip(ftype)
10821 
      elif fid == 2:
3064 chandransh 10822 
        if ftype == TType.MAP:
10823 
          self.pickupDetails = {}
4133 chandransh 10824 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10825 
          for _i144 in xrange(_size140):
10826 
            _key145 = iprot.readString();
10827 
            _val146 = iprot.readString();
10828 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10829 
          iprot.readMapEnd()
304 ashish 10830 
        else:
10831 
          iprot.skip(ftype)
10832 
      else:
10833 
        iprot.skip(ftype)
10834 
      iprot.readFieldEnd()
10835 
    iprot.readStructEnd()
10836 
 
10837 
  def write(self, oprot):
10838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10840 
      return
3064 chandransh 10841 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10842 
    if self.providerId is not None:
3064 chandransh 10843 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10844 
      oprot.writeI64(self.providerId)
304 ashish 10845 
      oprot.writeFieldEnd()
3431 rajveer 10846 
    if self.pickupDetails is not None:
3064 chandransh 10847 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10848 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10849 
      for kiter147,viter148 in self.pickupDetails.items():
10850 
        oprot.writeString(kiter147)
10851 
        oprot.writeString(viter148)
3064 chandransh 10852 
      oprot.writeMapEnd()
304 ashish 10853 
      oprot.writeFieldEnd()
10854 
    oprot.writeFieldStop()
10855 
    oprot.writeStructEnd()
10856 
 
3431 rajveer 10857 
  def validate(self):
10858 
    return
10859 
 
10860 
 
304 ashish 10861 
  def __repr__(self):
10862 
    L = ['%s=%r' % (key, value)
10863 
      for key, value in self.__dict__.iteritems()]
10864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10865 
 
10866 
  def __eq__(self, other):
10867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10868 
 
10869 
  def __ne__(self, other):
10870 
    return not (self == other)
10871 
 
3064 chandransh 10872 
class markOrdersAsPickedUp_result:
304 ashish 10873 
  """
10874 
  Attributes:
10875 
   - success
3064 chandransh 10876 
   - ex
304 ashish 10877 
  """
10878 
 
10879 
  thrift_spec = (
3064 chandransh 10880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10882 
  )
10883 
 
3064 chandransh 10884 
  def __init__(self, success=None, ex=None,):
304 ashish 10885 
    self.success = success
3064 chandransh 10886 
    self.ex = ex
304 ashish 10887 
 
10888 
  def read(self, iprot):
10889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10891 
      return
10892 
    iprot.readStructBegin()
10893 
    while True:
10894 
      (fname, ftype, fid) = iprot.readFieldBegin()
10895 
      if ftype == TType.STOP:
10896 
        break
10897 
      if fid == 0:
10898 
        if ftype == TType.LIST:
10899 
          self.success = []
4133 chandransh 10900 
          (_etype152, _size149) = iprot.readListBegin()
10901 
          for _i153 in xrange(_size149):
10902 
            _elem154 = Order()
10903 
            _elem154.read(iprot)
10904 
            self.success.append(_elem154)
304 ashish 10905 
          iprot.readListEnd()
10906 
        else:
10907 
          iprot.skip(ftype)
3064 chandransh 10908 
      elif fid == 1:
10909 
        if ftype == TType.STRUCT:
10910 
          self.ex = TransactionServiceException()
10911 
          self.ex.read(iprot)
10912 
        else:
10913 
          iprot.skip(ftype)
304 ashish 10914 
      else:
10915 
        iprot.skip(ftype)
10916 
      iprot.readFieldEnd()
10917 
    iprot.readStructEnd()
10918 
 
10919 
  def write(self, oprot):
10920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10922 
      return
3064 chandransh 10923 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10924 
    if self.success is not None:
304 ashish 10925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10927 
      for iter155 in self.success:
10928 
        iter155.write(oprot)
304 ashish 10929 
      oprot.writeListEnd()
10930 
      oprot.writeFieldEnd()
3431 rajveer 10931 
    if self.ex is not None:
3064 chandransh 10932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10933 
      self.ex.write(oprot)
10934 
      oprot.writeFieldEnd()
304 ashish 10935 
    oprot.writeFieldStop()
10936 
    oprot.writeStructEnd()
10937 
 
3431 rajveer 10938 
  def validate(self):
10939 
    return
10940 
 
10941 
 
304 ashish 10942 
  def __repr__(self):
10943 
    L = ['%s=%r' % (key, value)
10944 
      for key, value in self.__dict__.iteritems()]
10945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10946 
 
10947 
  def __eq__(self, other):
10948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10949 
 
10950 
  def __ne__(self, other):
10951 
    return not (self == other)
10952 
 
3064 chandransh 10953 
class markOrdersAsDelivered_args:
304 ashish 10954 
  """
10955 
  Attributes:
3064 chandransh 10956 
   - providerId
10957 
   - deliveredOrders
304 ashish 10958 
  """
10959 
 
10960 
  thrift_spec = (
10961 
    None, # 0
3064 chandransh 10962 
    (1, TType.I64, 'providerId', None, None, ), # 1
10963 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10964 
  )
10965 
 
3064 chandransh 10966 
  def __init__(self, providerId=None, deliveredOrders=None,):
10967 
    self.providerId = providerId
10968 
    self.deliveredOrders = deliveredOrders
304 ashish 10969 
 
10970 
  def read(self, iprot):
10971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10973 
      return
10974 
    iprot.readStructBegin()
10975 
    while True:
10976 
      (fname, ftype, fid) = iprot.readFieldBegin()
10977 
      if ftype == TType.STOP:
10978 
        break
10979 
      if fid == 1:
10980 
        if ftype == TType.I64:
3064 chandransh 10981 
          self.providerId = iprot.readI64();
304 ashish 10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      elif fid == 2:
3064 chandransh 10985 
        if ftype == TType.MAP:
10986 
          self.deliveredOrders = {}
4133 chandransh 10987 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10988 
          for _i160 in xrange(_size156):
10989 
            _key161 = iprot.readString();
10990 
            _val162 = iprot.readString();
10991 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10992 
          iprot.readMapEnd()
304 ashish 10993 
        else:
10994 
          iprot.skip(ftype)
10995 
      else:
10996 
        iprot.skip(ftype)
10997 
      iprot.readFieldEnd()
10998 
    iprot.readStructEnd()
10999 
 
11000 
  def write(self, oprot):
11001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11003 
      return
3064 chandransh 11004 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11005 
    if self.providerId is not None:
3064 chandransh 11006 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11007 
      oprot.writeI64(self.providerId)
304 ashish 11008 
      oprot.writeFieldEnd()
3431 rajveer 11009 
    if self.deliveredOrders is not None:
3064 chandransh 11010 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11011 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11012 
      for kiter163,viter164 in self.deliveredOrders.items():
11013 
        oprot.writeString(kiter163)
11014 
        oprot.writeString(viter164)
3064 chandransh 11015 
      oprot.writeMapEnd()
304 ashish 11016 
      oprot.writeFieldEnd()
11017 
    oprot.writeFieldStop()
11018 
    oprot.writeStructEnd()
11019 
 
3431 rajveer 11020 
  def validate(self):
11021 
    return
11022 
 
11023 
 
304 ashish 11024 
  def __repr__(self):
11025 
    L = ['%s=%r' % (key, value)
11026 
      for key, value in self.__dict__.iteritems()]
11027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11028 
 
11029 
  def __eq__(self, other):
11030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11031 
 
11032 
  def __ne__(self, other):
11033 
    return not (self == other)
11034 
 
3064 chandransh 11035 
class markOrdersAsDelivered_result:
11036 
  """
11037 
  Attributes:
11038 
   - ex
11039 
  """
304 ashish 11040 
 
11041 
  thrift_spec = (
3064 chandransh 11042 
    None, # 0
11043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11044 
  )
11045 
 
3064 chandransh 11046 
  def __init__(self, ex=None,):
11047 
    self.ex = ex
304 ashish 11048 
 
1596 ankur.sing 11049 
  def read(self, iprot):
11050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11052 
      return
11053 
    iprot.readStructBegin()
11054 
    while True:
11055 
      (fname, ftype, fid) = iprot.readFieldBegin()
11056 
      if ftype == TType.STOP:
11057 
        break
3064 chandransh 11058 
      if fid == 1:
11059 
        if ftype == TType.STRUCT:
11060 
          self.ex = TransactionServiceException()
11061 
          self.ex.read(iprot)
11062 
        else:
11063 
          iprot.skip(ftype)
1596 ankur.sing 11064 
      else:
11065 
        iprot.skip(ftype)
11066 
      iprot.readFieldEnd()
11067 
    iprot.readStructEnd()
11068 
 
11069 
  def write(self, oprot):
11070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11072 
      return
3064 chandransh 11073 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11074 
    if self.ex is not None:
3064 chandransh 11075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11076 
      self.ex.write(oprot)
11077 
      oprot.writeFieldEnd()
1596 ankur.sing 11078 
    oprot.writeFieldStop()
11079 
    oprot.writeStructEnd()
11080 
 
3431 rajveer 11081 
  def validate(self):
11082 
    return
11083 
 
11084 
 
1596 ankur.sing 11085 
  def __repr__(self):
11086 
    L = ['%s=%r' % (key, value)
11087 
      for key, value in self.__dict__.iteritems()]
11088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11089 
 
11090 
  def __eq__(self, other):
11091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11092 
 
11093 
  def __ne__(self, other):
11094 
    return not (self == other)
11095 
 
3064 chandransh 11096 
class markOrdersAsFailed_args:
1596 ankur.sing 11097 
  """
11098 
  Attributes:
3064 chandransh 11099 
   - providerId
11100 
   - returnedOrders
1596 ankur.sing 11101 
  """
11102 
 
11103 
  thrift_spec = (
3064 chandransh 11104 
    None, # 0
11105 
    (1, TType.I64, 'providerId', None, None, ), # 1
11106 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11107 
  )
11108 
 
3064 chandransh 11109 
  def __init__(self, providerId=None, returnedOrders=None,):
11110 
    self.providerId = providerId
11111 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11112 
 
11113 
  def read(self, iprot):
11114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11116 
      return
11117 
    iprot.readStructBegin()
11118 
    while True:
11119 
      (fname, ftype, fid) = iprot.readFieldBegin()
11120 
      if ftype == TType.STOP:
11121 
        break
3064 chandransh 11122 
      if fid == 1:
1596 ankur.sing 11123 
        if ftype == TType.I64:
3064 chandransh 11124 
          self.providerId = iprot.readI64();
1596 ankur.sing 11125 
        else:
11126 
          iprot.skip(ftype)
3064 chandransh 11127 
      elif fid == 2:
11128 
        if ftype == TType.MAP:
11129 
          self.returnedOrders = {}
4133 chandransh 11130 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11131 
          for _i169 in xrange(_size165):
11132 
            _key170 = iprot.readString();
11133 
            _val171 = iprot.readString();
11134 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11135 
          iprot.readMapEnd()
11136 
        else:
11137 
          iprot.skip(ftype)
1596 ankur.sing 11138 
      else:
11139 
        iprot.skip(ftype)
11140 
      iprot.readFieldEnd()
11141 
    iprot.readStructEnd()
11142 
 
11143 
  def write(self, oprot):
11144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11146 
      return
3064 chandransh 11147 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11148 
    if self.providerId is not None:
3064 chandransh 11149 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11150 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11151 
      oprot.writeFieldEnd()
3431 rajveer 11152 
    if self.returnedOrders is not None:
3064 chandransh 11153 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11154 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11155 
      for kiter172,viter173 in self.returnedOrders.items():
11156 
        oprot.writeString(kiter172)
11157 
        oprot.writeString(viter173)
3064 chandransh 11158 
      oprot.writeMapEnd()
11159 
      oprot.writeFieldEnd()
1596 ankur.sing 11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
1596 ankur.sing 11167 
  def __repr__(self):
11168 
    L = ['%s=%r' % (key, value)
11169 
      for key, value in self.__dict__.iteritems()]
11170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11171 
 
11172 
  def __eq__(self, other):
11173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11174 
 
11175 
  def __ne__(self, other):
11176 
    return not (self == other)
11177 
 
3064 chandransh 11178 
class markOrdersAsFailed_result:
11179 
  """
11180 
  Attributes:
11181 
   - ex
11182 
  """
1596 ankur.sing 11183 
 
1627 ankur.sing 11184 
  thrift_spec = (
3064 chandransh 11185 
    None, # 0
11186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11187 
  )
11188 
 
3064 chandransh 11189 
  def __init__(self, ex=None,):
11190 
    self.ex = ex
11191 
 
1627 ankur.sing 11192 
  def read(self, iprot):
11193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11195 
      return
11196 
    iprot.readStructBegin()
11197 
    while True:
11198 
      (fname, ftype, fid) = iprot.readFieldBegin()
11199 
      if ftype == TType.STOP:
11200 
        break
3064 chandransh 11201 
      if fid == 1:
11202 
        if ftype == TType.STRUCT:
11203 
          self.ex = TransactionServiceException()
11204 
          self.ex.read(iprot)
11205 
        else:
11206 
          iprot.skip(ftype)
1627 ankur.sing 11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
3064 chandransh 11216 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11217 
    if self.ex is not None:
3064 chandransh 11218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11219 
      self.ex.write(oprot)
11220 
      oprot.writeFieldEnd()
1627 ankur.sing 11221 
    oprot.writeFieldStop()
11222 
    oprot.writeStructEnd()
11223 
 
3431 rajveer 11224 
  def validate(self):
11225 
    return
11226 
 
11227 
 
1627 ankur.sing 11228 
  def __repr__(self):
11229 
    L = ['%s=%r' % (key, value)
11230 
      for key, value in self.__dict__.iteritems()]
11231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11232 
 
11233 
  def __eq__(self, other):
11234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11235 
 
11236 
  def __ne__(self, other):
11237 
    return not (self == other)
11238 
 
3064 chandransh 11239 
class updateNonDeliveryReason_args:
1627 ankur.sing 11240 
  """
11241 
  Attributes:
3064 chandransh 11242 
   - providerId
11243 
   - undeliveredOrders
1627 ankur.sing 11244 
  """
11245 
 
11246 
  thrift_spec = (
3064 chandransh 11247 
    None, # 0
11248 
    (1, TType.I64, 'providerId', None, None, ), # 1
11249 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11250 
  )
11251 
 
3064 chandransh 11252 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11253 
    self.providerId = providerId
11254 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
3064 chandransh 11265 
      if fid == 1:
1627 ankur.sing 11266 
        if ftype == TType.I64:
3064 chandransh 11267 
          self.providerId = iprot.readI64();
1627 ankur.sing 11268 
        else:
11269 
          iprot.skip(ftype)
3064 chandransh 11270 
      elif fid == 2:
11271 
        if ftype == TType.MAP:
11272 
          self.undeliveredOrders = {}
4133 chandransh 11273 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11274 
          for _i178 in xrange(_size174):
11275 
            _key179 = iprot.readString();
11276 
            _val180 = iprot.readString();
11277 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11278 
          iprot.readMapEnd()
11279 
        else:
11280 
          iprot.skip(ftype)
1627 ankur.sing 11281 
      else:
11282 
        iprot.skip(ftype)
11283 
      iprot.readFieldEnd()
11284 
    iprot.readStructEnd()
11285 
 
11286 
  def write(self, oprot):
11287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11289 
      return
3064 chandransh 11290 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11291 
    if self.providerId is not None:
3064 chandransh 11292 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11293 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11294 
      oprot.writeFieldEnd()
3431 rajveer 11295 
    if self.undeliveredOrders is not None:
3064 chandransh 11296 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11297 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11298 
      for kiter181,viter182 in self.undeliveredOrders.items():
11299 
        oprot.writeString(kiter181)
11300 
        oprot.writeString(viter182)
3064 chandransh 11301 
      oprot.writeMapEnd()
11302 
      oprot.writeFieldEnd()
1627 ankur.sing 11303 
    oprot.writeFieldStop()
11304 
    oprot.writeStructEnd()
11305 
 
3431 rajveer 11306 
  def validate(self):
11307 
    return
11308 
 
11309 
 
1627 ankur.sing 11310 
  def __repr__(self):
11311 
    L = ['%s=%r' % (key, value)
11312 
      for key, value in self.__dict__.iteritems()]
11313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11314 
 
11315 
  def __eq__(self, other):
11316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11317 
 
11318 
  def __ne__(self, other):
11319 
    return not (self == other)
11320 
 
3064 chandransh 11321 
class updateNonDeliveryReason_result:
1627 ankur.sing 11322 
  """
11323 
  Attributes:
4581 phani.kuma 11324 
   - success
3064 chandransh 11325 
   - ex
1627 ankur.sing 11326 
  """
11327 
 
11328 
  thrift_spec = (
4581 phani.kuma 11329 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11331 
  )
11332 
 
4581 phani.kuma 11333 
  def __init__(self, success=None, ex=None,):
11334 
    self.success = success
3064 chandransh 11335 
    self.ex = ex
1627 ankur.sing 11336 
 
11337 
  def read(self, iprot):
11338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11340 
      return
11341 
    iprot.readStructBegin()
11342 
    while True:
11343 
      (fname, ftype, fid) = iprot.readFieldBegin()
11344 
      if ftype == TType.STOP:
11345 
        break
4581 phani.kuma 11346 
      if fid == 0:
11347 
        if ftype == TType.LIST:
11348 
          self.success = []
11349 
          (_etype186, _size183) = iprot.readListBegin()
11350 
          for _i187 in xrange(_size183):
11351 
            _elem188 = Order()
11352 
            _elem188.read(iprot)
11353 
            self.success.append(_elem188)
11354 
          iprot.readListEnd()
11355 
        else:
11356 
          iprot.skip(ftype)
11357 
      elif fid == 1:
3064 chandransh 11358 
        if ftype == TType.STRUCT:
11359 
          self.ex = TransactionServiceException()
11360 
          self.ex.read(iprot)
1627 ankur.sing 11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      else:
11364 
        iprot.skip(ftype)
11365 
      iprot.readFieldEnd()
11366 
    iprot.readStructEnd()
11367 
 
11368 
  def write(self, oprot):
11369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11371 
      return
3064 chandransh 11372 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11373 
    if self.success is not None:
11374 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11375 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11376 
      for iter189 in self.success:
11377 
        iter189.write(oprot)
11378 
      oprot.writeListEnd()
11379 
      oprot.writeFieldEnd()
3431 rajveer 11380 
    if self.ex is not None:
3064 chandransh 11381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11382 
      self.ex.write(oprot)
1627 ankur.sing 11383 
      oprot.writeFieldEnd()
11384 
    oprot.writeFieldStop()
11385 
    oprot.writeStructEnd()
11386 
 
3431 rajveer 11387 
  def validate(self):
11388 
    return
11389 
 
11390 
 
1627 ankur.sing 11391 
  def __repr__(self):
11392 
    L = ['%s=%r' % (key, value)
11393 
      for key, value in self.__dict__.iteritems()]
11394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11395 
 
11396 
  def __eq__(self, other):
11397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11398 
 
11399 
  def __ne__(self, other):
11400 
    return not (self == other)
11401 
 
3064 chandransh 11402 
class getUndeliveredOrders_args:
1886 ankur.sing 11403 
  """
11404 
  Attributes:
3064 chandransh 11405 
   - providerId
11406 
   - warehouseId
1886 ankur.sing 11407 
  """
1627 ankur.sing 11408 
 
1886 ankur.sing 11409 
  thrift_spec = (
11410 
    None, # 0
3064 chandransh 11411 
    (1, TType.I64, 'providerId', None, None, ), # 1
11412 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11413 
  )
11414 
 
3064 chandransh 11415 
  def __init__(self, providerId=None, warehouseId=None,):
11416 
    self.providerId = providerId
11417 
    self.warehouseId = warehouseId
1886 ankur.sing 11418 
 
11419 
  def read(self, iprot):
11420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11422 
      return
11423 
    iprot.readStructBegin()
11424 
    while True:
11425 
      (fname, ftype, fid) = iprot.readFieldBegin()
11426 
      if ftype == TType.STOP:
11427 
        break
11428 
      if fid == 1:
11429 
        if ftype == TType.I64:
3064 chandransh 11430 
          self.providerId = iprot.readI64();
1886 ankur.sing 11431 
        else:
11432 
          iprot.skip(ftype)
3064 chandransh 11433 
      elif fid == 2:
11434 
        if ftype == TType.I64:
11435 
          self.warehouseId = iprot.readI64();
11436 
        else:
11437 
          iprot.skip(ftype)
1886 ankur.sing 11438 
      else:
11439 
        iprot.skip(ftype)
11440 
      iprot.readFieldEnd()
11441 
    iprot.readStructEnd()
11442 
 
11443 
  def write(self, oprot):
11444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11446 
      return
3064 chandransh 11447 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11448 
    if self.providerId is not None:
3064 chandransh 11449 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11450 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11451 
      oprot.writeFieldEnd()
3431 rajveer 11452 
    if self.warehouseId is not None:
3064 chandransh 11453 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11454 
      oprot.writeI64(self.warehouseId)
11455 
      oprot.writeFieldEnd()
1886 ankur.sing 11456 
    oprot.writeFieldStop()
11457 
    oprot.writeStructEnd()
11458 
 
3431 rajveer 11459 
  def validate(self):
11460 
    return
11461 
 
11462 
 
1886 ankur.sing 11463 
  def __repr__(self):
11464 
    L = ['%s=%r' % (key, value)
11465 
      for key, value in self.__dict__.iteritems()]
11466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11467 
 
11468 
  def __eq__(self, other):
11469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11470 
 
11471 
  def __ne__(self, other):
11472 
    return not (self == other)
11473 
 
3064 chandransh 11474 
class getUndeliveredOrders_result:
1886 ankur.sing 11475 
  """
11476 
  Attributes:
11477 
   - success
11478 
  """
11479 
 
11480 
  thrift_spec = (
11481 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11482 
  )
11483 
 
11484 
  def __init__(self, success=None,):
11485 
    self.success = success
11486 
 
11487 
  def read(self, iprot):
11488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11490 
      return
11491 
    iprot.readStructBegin()
11492 
    while True:
11493 
      (fname, ftype, fid) = iprot.readFieldBegin()
11494 
      if ftype == TType.STOP:
11495 
        break
11496 
      if fid == 0:
11497 
        if ftype == TType.LIST:
11498 
          self.success = []
4581 phani.kuma 11499 
          (_etype193, _size190) = iprot.readListBegin()
11500 
          for _i194 in xrange(_size190):
11501 
            _elem195 = Order()
11502 
            _elem195.read(iprot)
11503 
            self.success.append(_elem195)
1886 ankur.sing 11504 
          iprot.readListEnd()
11505 
        else:
11506 
          iprot.skip(ftype)
11507 
      else:
11508 
        iprot.skip(ftype)
11509 
      iprot.readFieldEnd()
11510 
    iprot.readStructEnd()
11511 
 
11512 
  def write(self, oprot):
11513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11515 
      return
3064 chandransh 11516 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11517 
    if self.success is not None:
1886 ankur.sing 11518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11520 
      for iter196 in self.success:
11521 
        iter196.write(oprot)
1886 ankur.sing 11522 
      oprot.writeListEnd()
11523 
      oprot.writeFieldEnd()
11524 
    oprot.writeFieldStop()
11525 
    oprot.writeStructEnd()
11526 
 
3431 rajveer 11527 
  def validate(self):
11528 
    return
11529 
 
11530 
 
1886 ankur.sing 11531 
  def __repr__(self):
11532 
    L = ['%s=%r' % (key, value)
11533 
      for key, value in self.__dict__.iteritems()]
11534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11535 
 
11536 
  def __eq__(self, other):
11537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11538 
 
11539 
  def __ne__(self, other):
11540 
    return not (self == other)
11541 
 
2536 chandransh 11542 
class toggleDOAFlag_args:
11543 
  """
11544 
  Attributes:
11545 
   - orderId
11546 
  """
1886 ankur.sing 11547 
 
2536 chandransh 11548 
  thrift_spec = (
11549 
    None, # 0
11550 
    (1, TType.I64, 'orderId', None, None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, orderId=None,):
11554 
    self.orderId = orderId
11555 
 
11556 
  def read(self, iprot):
11557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11559 
      return
11560 
    iprot.readStructBegin()
11561 
    while True:
11562 
      (fname, ftype, fid) = iprot.readFieldBegin()
11563 
      if ftype == TType.STOP:
11564 
        break
11565 
      if fid == 1:
11566 
        if ftype == TType.I64:
11567 
          self.orderId = iprot.readI64();
11568 
        else:
11569 
          iprot.skip(ftype)
11570 
      else:
11571 
        iprot.skip(ftype)
11572 
      iprot.readFieldEnd()
11573 
    iprot.readStructEnd()
11574 
 
11575 
  def write(self, oprot):
11576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11578 
      return
11579 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11580 
    if self.orderId is not None:
2536 chandransh 11581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11582 
      oprot.writeI64(self.orderId)
11583 
      oprot.writeFieldEnd()
11584 
    oprot.writeFieldStop()
11585 
    oprot.writeStructEnd()
11586 
 
3431 rajveer 11587 
  def validate(self):
11588 
    return
11589 
 
11590 
 
2536 chandransh 11591 
  def __repr__(self):
11592 
    L = ['%s=%r' % (key, value)
11593 
      for key, value in self.__dict__.iteritems()]
11594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11595 
 
11596 
  def __eq__(self, other):
11597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11598 
 
11599 
  def __ne__(self, other):
11600 
    return not (self == other)
11601 
 
11602 
class toggleDOAFlag_result:
11603 
  """
11604 
  Attributes:
11605 
   - success
11606 
   - ex
11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    (0, TType.BOOL, 'success', None, None, ), # 0
11611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11612 
  )
11613 
 
11614 
  def __init__(self, success=None, ex=None,):
11615 
    self.success = success
11616 
    self.ex = ex
11617 
 
11618 
  def read(self, iprot):
11619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11621 
      return
11622 
    iprot.readStructBegin()
11623 
    while True:
11624 
      (fname, ftype, fid) = iprot.readFieldBegin()
11625 
      if ftype == TType.STOP:
11626 
        break
11627 
      if fid == 0:
11628 
        if ftype == TType.BOOL:
11629 
          self.success = iprot.readBool();
11630 
        else:
11631 
          iprot.skip(ftype)
11632 
      elif fid == 1:
11633 
        if ftype == TType.STRUCT:
11634 
          self.ex = TransactionServiceException()
11635 
          self.ex.read(iprot)
11636 
        else:
11637 
          iprot.skip(ftype)
11638 
      else:
11639 
        iprot.skip(ftype)
11640 
      iprot.readFieldEnd()
11641 
    iprot.readStructEnd()
11642 
 
11643 
  def write(self, oprot):
11644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11646 
      return
11647 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11648 
    if self.success is not None:
2536 chandransh 11649 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11650 
      oprot.writeBool(self.success)
11651 
      oprot.writeFieldEnd()
3431 rajveer 11652 
    if self.ex is not None:
2536 chandransh 11653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11654 
      self.ex.write(oprot)
11655 
      oprot.writeFieldEnd()
11656 
    oprot.writeFieldStop()
11657 
    oprot.writeStructEnd()
11658 
 
3431 rajveer 11659 
  def validate(self):
11660 
    return
11661 
 
11662 
 
2536 chandransh 11663 
  def __repr__(self):
11664 
    L = ['%s=%r' % (key, value)
11665 
      for key, value in self.__dict__.iteritems()]
11666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11667 
 
11668 
  def __eq__(self, other):
11669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11670 
 
11671 
  def __ne__(self, other):
11672 
    return not (self == other)
11673 
 
4454 rajveer 11674 
class markOrderDoaRequestReceived_args:
11675 
  """
11676 
  Attributes:
11677 
   - orderId
11678 
  """
11679 
 
11680 
  thrift_spec = (
11681 
    None, # 0
11682 
    (1, TType.I64, 'orderId', None, None, ), # 1
11683 
  )
11684 
 
11685 
  def __init__(self, orderId=None,):
11686 
    self.orderId = orderId
11687 
 
11688 
  def read(self, iprot):
11689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11691 
      return
11692 
    iprot.readStructBegin()
11693 
    while True:
11694 
      (fname, ftype, fid) = iprot.readFieldBegin()
11695 
      if ftype == TType.STOP:
11696 
        break
11697 
      if fid == 1:
11698 
        if ftype == TType.I64:
11699 
          self.orderId = iprot.readI64();
11700 
        else:
11701 
          iprot.skip(ftype)
11702 
      else:
11703 
        iprot.skip(ftype)
11704 
      iprot.readFieldEnd()
11705 
    iprot.readStructEnd()
11706 
 
11707 
  def write(self, oprot):
11708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11710 
      return
11711 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11712 
    if self.orderId is not None:
11713 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11714 
      oprot.writeI64(self.orderId)
11715 
      oprot.writeFieldEnd()
11716 
    oprot.writeFieldStop()
11717 
    oprot.writeStructEnd()
11718 
 
11719 
  def validate(self):
11720 
    return
11721 
 
11722 
 
11723 
  def __repr__(self):
11724 
    L = ['%s=%r' % (key, value)
11725 
      for key, value in self.__dict__.iteritems()]
11726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11727 
 
11728 
  def __eq__(self, other):
11729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11730 
 
11731 
  def __ne__(self, other):
11732 
    return not (self == other)
11733 
 
11734 
class markOrderDoaRequestReceived_result:
11735 
  """
11736 
  Attributes:
11737 
   - success
11738 
   - ex
11739 
  """
11740 
 
11741 
  thrift_spec = (
11742 
    (0, TType.BOOL, 'success', None, None, ), # 0
11743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11744 
  )
11745 
 
11746 
  def __init__(self, success=None, ex=None,):
11747 
    self.success = success
11748 
    self.ex = ex
11749 
 
11750 
  def read(self, iprot):
11751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11753 
      return
11754 
    iprot.readStructBegin()
11755 
    while True:
11756 
      (fname, ftype, fid) = iprot.readFieldBegin()
11757 
      if ftype == TType.STOP:
11758 
        break
11759 
      if fid == 0:
11760 
        if ftype == TType.BOOL:
11761 
          self.success = iprot.readBool();
11762 
        else:
11763 
          iprot.skip(ftype)
11764 
      elif fid == 1:
11765 
        if ftype == TType.STRUCT:
11766 
          self.ex = TransactionServiceException()
11767 
          self.ex.read(iprot)
11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
11779 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11780 
    if self.success is not None:
11781 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11782 
      oprot.writeBool(self.success)
11783 
      oprot.writeFieldEnd()
11784 
    if self.ex is not None:
11785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11786 
      self.ex.write(oprot)
11787 
      oprot.writeFieldEnd()
11788 
    oprot.writeFieldStop()
11789 
    oprot.writeStructEnd()
11790 
 
11791 
  def validate(self):
11792 
    return
11793 
 
11794 
 
11795 
  def __repr__(self):
11796 
    L = ['%s=%r' % (key, value)
11797 
      for key, value in self.__dict__.iteritems()]
11798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11799 
 
11800 
  def __eq__(self, other):
11801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11802 
 
11803 
  def __ne__(self, other):
11804 
    return not (self == other)
11805 
 
11806 
class markOrderDoaRequestAuthorized_args:
11807 
  """
11808 
  Attributes:
11809 
   - orderId
11810 
   - isAuthorized
11811 
  """
11812 
 
11813 
  thrift_spec = (
11814 
    None, # 0
11815 
    (1, TType.I64, 'orderId', None, None, ), # 1
11816 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11817 
  )
11818 
 
11819 
  def __init__(self, orderId=None, isAuthorized=None,):
11820 
    self.orderId = orderId
11821 
    self.isAuthorized = isAuthorized
11822 
 
11823 
  def read(self, iprot):
11824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11826 
      return
11827 
    iprot.readStructBegin()
11828 
    while True:
11829 
      (fname, ftype, fid) = iprot.readFieldBegin()
11830 
      if ftype == TType.STOP:
11831 
        break
11832 
      if fid == 1:
11833 
        if ftype == TType.I64:
11834 
          self.orderId = iprot.readI64();
11835 
        else:
11836 
          iprot.skip(ftype)
11837 
      elif fid == 2:
11838 
        if ftype == TType.BOOL:
11839 
          self.isAuthorized = iprot.readBool();
11840 
        else:
11841 
          iprot.skip(ftype)
11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
11851 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11852 
    if self.orderId is not None:
11853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11854 
      oprot.writeI64(self.orderId)
11855 
      oprot.writeFieldEnd()
11856 
    if self.isAuthorized is not None:
11857 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11858 
      oprot.writeBool(self.isAuthorized)
11859 
      oprot.writeFieldEnd()
11860 
    oprot.writeFieldStop()
11861 
    oprot.writeStructEnd()
11862 
 
11863 
  def validate(self):
11864 
    return
11865 
 
11866 
 
11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
11877 
 
11878 
class markOrderDoaRequestAuthorized_result:
11879 
  """
11880 
  Attributes:
11881 
   - success
11882 
   - ex
11883 
  """
11884 
 
11885 
  thrift_spec = (
11886 
    (0, TType.BOOL, 'success', None, None, ), # 0
11887 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11888 
  )
11889 
 
11890 
  def __init__(self, success=None, ex=None,):
11891 
    self.success = success
11892 
    self.ex = ex
11893 
 
11894 
  def read(self, iprot):
11895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11897 
      return
11898 
    iprot.readStructBegin()
11899 
    while True:
11900 
      (fname, ftype, fid) = iprot.readFieldBegin()
11901 
      if ftype == TType.STOP:
11902 
        break
11903 
      if fid == 0:
11904 
        if ftype == TType.BOOL:
11905 
          self.success = iprot.readBool();
11906 
        else:
11907 
          iprot.skip(ftype)
11908 
      elif fid == 1:
11909 
        if ftype == TType.STRUCT:
11910 
          self.ex = TransactionServiceException()
11911 
          self.ex.read(iprot)
11912 
        else:
11913 
          iprot.skip(ftype)
11914 
      else:
11915 
        iprot.skip(ftype)
11916 
      iprot.readFieldEnd()
11917 
    iprot.readStructEnd()
11918 
 
11919 
  def write(self, oprot):
11920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11922 
      return
11923 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11924 
    if self.success is not None:
11925 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11926 
      oprot.writeBool(self.success)
11927 
      oprot.writeFieldEnd()
11928 
    if self.ex is not None:
11929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11930 
      self.ex.write(oprot)
11931 
      oprot.writeFieldEnd()
11932 
    oprot.writeFieldStop()
11933 
    oprot.writeStructEnd()
11934 
 
11935 
  def validate(self):
11936 
    return
11937 
 
11938 
 
11939 
  def __repr__(self):
11940 
    L = ['%s=%r' % (key, value)
11941 
      for key, value in self.__dict__.iteritems()]
11942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11943 
 
11944 
  def __eq__(self, other):
11945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11946 
 
11947 
  def __ne__(self, other):
11948 
    return not (self == other)
11949 
 
4488 rajveer 11950 
class markOrderReturnRequestReceived_args:
11951 
  """
11952 
  Attributes:
11953 
   - orderId
11954 
  """
11955 
 
11956 
  thrift_spec = (
11957 
    None, # 0
11958 
    (1, TType.I64, 'orderId', None, None, ), # 1
11959 
  )
11960 
 
11961 
  def __init__(self, orderId=None,):
11962 
    self.orderId = orderId
11963 
 
11964 
  def read(self, iprot):
11965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11967 
      return
11968 
    iprot.readStructBegin()
11969 
    while True:
11970 
      (fname, ftype, fid) = iprot.readFieldBegin()
11971 
      if ftype == TType.STOP:
11972 
        break
11973 
      if fid == 1:
11974 
        if ftype == TType.I64:
11975 
          self.orderId = iprot.readI64();
11976 
        else:
11977 
          iprot.skip(ftype)
11978 
      else:
11979 
        iprot.skip(ftype)
11980 
      iprot.readFieldEnd()
11981 
    iprot.readStructEnd()
11982 
 
11983 
  def write(self, oprot):
11984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11986 
      return
11987 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11988 
    if self.orderId is not None:
11989 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11990 
      oprot.writeI64(self.orderId)
11991 
      oprot.writeFieldEnd()
11992 
    oprot.writeFieldStop()
11993 
    oprot.writeStructEnd()
11994 
 
11995 
  def validate(self):
11996 
    return
11997 
 
11998 
 
11999 
  def __repr__(self):
12000 
    L = ['%s=%r' % (key, value)
12001 
      for key, value in self.__dict__.iteritems()]
12002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12003 
 
12004 
  def __eq__(self, other):
12005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12006 
 
12007 
  def __ne__(self, other):
12008 
    return not (self == other)
12009 
 
12010 
class markOrderReturnRequestReceived_result:
12011 
  """
12012 
  Attributes:
12013 
   - success
12014 
   - ex
12015 
  """
12016 
 
12017 
  thrift_spec = (
12018 
    (0, TType.BOOL, 'success', None, None, ), # 0
12019 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12020 
  )
12021 
 
12022 
  def __init__(self, success=None, ex=None,):
12023 
    self.success = success
12024 
    self.ex = ex
12025 
 
12026 
  def read(self, iprot):
12027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12029 
      return
12030 
    iprot.readStructBegin()
12031 
    while True:
12032 
      (fname, ftype, fid) = iprot.readFieldBegin()
12033 
      if ftype == TType.STOP:
12034 
        break
12035 
      if fid == 0:
12036 
        if ftype == TType.BOOL:
12037 
          self.success = iprot.readBool();
12038 
        else:
12039 
          iprot.skip(ftype)
12040 
      elif fid == 1:
12041 
        if ftype == TType.STRUCT:
12042 
          self.ex = TransactionServiceException()
12043 
          self.ex.read(iprot)
12044 
        else:
12045 
          iprot.skip(ftype)
12046 
      else:
12047 
        iprot.skip(ftype)
12048 
      iprot.readFieldEnd()
12049 
    iprot.readStructEnd()
12050 
 
12051 
  def write(self, oprot):
12052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12054 
      return
12055 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12056 
    if self.success is not None:
12057 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12058 
      oprot.writeBool(self.success)
12059 
      oprot.writeFieldEnd()
12060 
    if self.ex is not None:
12061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12062 
      self.ex.write(oprot)
12063 
      oprot.writeFieldEnd()
12064 
    oprot.writeFieldStop()
12065 
    oprot.writeStructEnd()
12066 
 
12067 
  def validate(self):
12068 
    return
12069 
 
12070 
 
12071 
  def __repr__(self):
12072 
    L = ['%s=%r' % (key, value)
12073 
      for key, value in self.__dict__.iteritems()]
12074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12075 
 
12076 
  def __eq__(self, other):
12077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12078 
 
12079 
  def __ne__(self, other):
12080 
    return not (self == other)
12081 
 
12082 
class markOrderReturnRequestAuthorized_args:
12083 
  """
12084 
  Attributes:
12085 
   - orderId
12086 
   - isAuthorized
12087 
  """
12088 
 
12089 
  thrift_spec = (
12090 
    None, # 0
12091 
    (1, TType.I64, 'orderId', None, None, ), # 1
12092 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12093 
  )
12094 
 
12095 
  def __init__(self, orderId=None, isAuthorized=None,):
12096 
    self.orderId = orderId
12097 
    self.isAuthorized = isAuthorized
12098 
 
12099 
  def read(self, iprot):
12100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12102 
      return
12103 
    iprot.readStructBegin()
12104 
    while True:
12105 
      (fname, ftype, fid) = iprot.readFieldBegin()
12106 
      if ftype == TType.STOP:
12107 
        break
12108 
      if fid == 1:
12109 
        if ftype == TType.I64:
12110 
          self.orderId = iprot.readI64();
12111 
        else:
12112 
          iprot.skip(ftype)
12113 
      elif fid == 2:
12114 
        if ftype == TType.BOOL:
12115 
          self.isAuthorized = iprot.readBool();
12116 
        else:
12117 
          iprot.skip(ftype)
12118 
      else:
12119 
        iprot.skip(ftype)
12120 
      iprot.readFieldEnd()
12121 
    iprot.readStructEnd()
12122 
 
12123 
  def write(self, oprot):
12124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12126 
      return
12127 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12128 
    if self.orderId is not None:
12129 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12130 
      oprot.writeI64(self.orderId)
12131 
      oprot.writeFieldEnd()
12132 
    if self.isAuthorized is not None:
12133 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12134 
      oprot.writeBool(self.isAuthorized)
12135 
      oprot.writeFieldEnd()
12136 
    oprot.writeFieldStop()
12137 
    oprot.writeStructEnd()
12138 
 
12139 
  def validate(self):
12140 
    return
12141 
 
12142 
 
12143 
  def __repr__(self):
12144 
    L = ['%s=%r' % (key, value)
12145 
      for key, value in self.__dict__.iteritems()]
12146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12147 
 
12148 
  def __eq__(self, other):
12149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12150 
 
12151 
  def __ne__(self, other):
12152 
    return not (self == other)
12153 
 
12154 
class markOrderReturnRequestAuthorized_result:
12155 
  """
12156 
  Attributes:
12157 
   - success
12158 
   - ex
12159 
  """
12160 
 
12161 
  thrift_spec = (
12162 
    (0, TType.BOOL, 'success', None, None, ), # 0
12163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12164 
  )
12165 
 
12166 
  def __init__(self, success=None, ex=None,):
12167 
    self.success = success
12168 
    self.ex = ex
12169 
 
12170 
  def read(self, iprot):
12171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12173 
      return
12174 
    iprot.readStructBegin()
12175 
    while True:
12176 
      (fname, ftype, fid) = iprot.readFieldBegin()
12177 
      if ftype == TType.STOP:
12178 
        break
12179 
      if fid == 0:
12180 
        if ftype == TType.BOOL:
12181 
          self.success = iprot.readBool();
12182 
        else:
12183 
          iprot.skip(ftype)
12184 
      elif fid == 1:
12185 
        if ftype == TType.STRUCT:
12186 
          self.ex = TransactionServiceException()
12187 
          self.ex.read(iprot)
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      else:
12191 
        iprot.skip(ftype)
12192 
      iprot.readFieldEnd()
12193 
    iprot.readStructEnd()
12194 
 
12195 
  def write(self, oprot):
12196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12198 
      return
12199 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12200 
    if self.success is not None:
12201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12202 
      oprot.writeBool(self.success)
12203 
      oprot.writeFieldEnd()
12204 
    if self.ex is not None:
12205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12206 
      self.ex.write(oprot)
12207 
      oprot.writeFieldEnd()
12208 
    oprot.writeFieldStop()
12209 
    oprot.writeStructEnd()
12210 
 
12211 
  def validate(self):
12212 
    return
12213 
 
12214 
 
12215 
  def __repr__(self):
12216 
    L = ['%s=%r' % (key, value)
12217 
      for key, value in self.__dict__.iteritems()]
12218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12219 
 
12220 
  def __eq__(self, other):
12221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12222 
 
12223 
  def __ne__(self, other):
12224 
    return not (self == other)
12225 
 
2536 chandransh 12226 
class requestPickupNumber_args:
12227 
  """
12228 
  Attributes:
12229 
   - orderId
4579 rajveer 12230 
   - providerId
2536 chandransh 12231 
  """
12232 
 
12233 
  thrift_spec = (
12234 
    None, # 0
12235 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12236 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12237 
  )
12238 
 
4579 rajveer 12239 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12240 
    self.orderId = orderId
4579 rajveer 12241 
    self.providerId = providerId
2536 chandransh 12242 
 
12243 
  def read(self, iprot):
12244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12246 
      return
12247 
    iprot.readStructBegin()
12248 
    while True:
12249 
      (fname, ftype, fid) = iprot.readFieldBegin()
12250 
      if ftype == TType.STOP:
12251 
        break
12252 
      if fid == 1:
12253 
        if ftype == TType.I64:
12254 
          self.orderId = iprot.readI64();
12255 
        else:
12256 
          iprot.skip(ftype)
4579 rajveer 12257 
      elif fid == 2:
12258 
        if ftype == TType.I64:
12259 
          self.providerId = iprot.readI64();
12260 
        else:
12261 
          iprot.skip(ftype)
2536 chandransh 12262 
      else:
12263 
        iprot.skip(ftype)
12264 
      iprot.readFieldEnd()
12265 
    iprot.readStructEnd()
12266 
 
12267 
  def write(self, oprot):
12268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12270 
      return
12271 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12272 
    if self.orderId is not None:
2536 chandransh 12273 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12274 
      oprot.writeI64(self.orderId)
12275 
      oprot.writeFieldEnd()
4579 rajveer 12276 
    if self.providerId is not None:
12277 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12278 
      oprot.writeI64(self.providerId)
12279 
      oprot.writeFieldEnd()
2536 chandransh 12280 
    oprot.writeFieldStop()
12281 
    oprot.writeStructEnd()
12282 
 
3431 rajveer 12283 
  def validate(self):
12284 
    return
12285 
 
12286 
 
2536 chandransh 12287 
  def __repr__(self):
12288 
    L = ['%s=%r' % (key, value)
12289 
      for key, value in self.__dict__.iteritems()]
12290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12291 
 
12292 
  def __eq__(self, other):
12293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12294 
 
12295 
  def __ne__(self, other):
12296 
    return not (self == other)
12297 
 
12298 
class requestPickupNumber_result:
12299 
  """
12300 
  Attributes:
12301 
   - success
12302 
   - ex
12303 
  """
12304 
 
12305 
  thrift_spec = (
12306 
    (0, TType.BOOL, 'success', None, None, ), # 0
12307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12308 
  )
12309 
 
12310 
  def __init__(self, success=None, ex=None,):
12311 
    self.success = success
12312 
    self.ex = ex
12313 
 
12314 
  def read(self, iprot):
12315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12317 
      return
12318 
    iprot.readStructBegin()
12319 
    while True:
12320 
      (fname, ftype, fid) = iprot.readFieldBegin()
12321 
      if ftype == TType.STOP:
12322 
        break
12323 
      if fid == 0:
12324 
        if ftype == TType.BOOL:
12325 
          self.success = iprot.readBool();
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      elif fid == 1:
12329 
        if ftype == TType.STRUCT:
12330 
          self.ex = TransactionServiceException()
12331 
          self.ex.read(iprot)
12332 
        else:
12333 
          iprot.skip(ftype)
12334 
      else:
12335 
        iprot.skip(ftype)
12336 
      iprot.readFieldEnd()
12337 
    iprot.readStructEnd()
12338 
 
12339 
  def write(self, oprot):
12340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12342 
      return
12343 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12344 
    if self.success is not None:
2536 chandransh 12345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12346 
      oprot.writeBool(self.success)
12347 
      oprot.writeFieldEnd()
3431 rajveer 12348 
    if self.ex is not None:
2536 chandransh 12349 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12350 
      self.ex.write(oprot)
12351 
      oprot.writeFieldEnd()
12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
3431 rajveer 12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
2536 chandransh 12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
12370 
class authorizePickup_args:
12371 
  """
12372 
  Attributes:
12373 
   - orderId
12374 
   - pickupNumber
4602 rajveer 12375 
   - providerId
2536 chandransh 12376 
  """
12377 
 
12378 
  thrift_spec = (
12379 
    None, # 0
12380 
    (1, TType.I64, 'orderId', None, None, ), # 1
12381 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12382 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12383 
  )
12384 
 
4602 rajveer 12385 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12386 
    self.orderId = orderId
12387 
    self.pickupNumber = pickupNumber
4602 rajveer 12388 
    self.providerId = providerId
2536 chandransh 12389 
 
12390 
  def read(self, iprot):
12391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12393 
      return
12394 
    iprot.readStructBegin()
12395 
    while True:
12396 
      (fname, ftype, fid) = iprot.readFieldBegin()
12397 
      if ftype == TType.STOP:
12398 
        break
12399 
      if fid == 1:
12400 
        if ftype == TType.I64:
12401 
          self.orderId = iprot.readI64();
12402 
        else:
12403 
          iprot.skip(ftype)
12404 
      elif fid == 2:
12405 
        if ftype == TType.STRING:
12406 
          self.pickupNumber = iprot.readString();
12407 
        else:
12408 
          iprot.skip(ftype)
4602 rajveer 12409 
      elif fid == 3:
12410 
        if ftype == TType.I64:
12411 
          self.providerId = iprot.readI64();
12412 
        else:
12413 
          iprot.skip(ftype)
2536 chandransh 12414 
      else:
12415 
        iprot.skip(ftype)
12416 
      iprot.readFieldEnd()
12417 
    iprot.readStructEnd()
12418 
 
12419 
  def write(self, oprot):
12420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12422 
      return
12423 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12424 
    if self.orderId is not None:
2536 chandransh 12425 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12426 
      oprot.writeI64(self.orderId)
12427 
      oprot.writeFieldEnd()
3431 rajveer 12428 
    if self.pickupNumber is not None:
2536 chandransh 12429 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12430 
      oprot.writeString(self.pickupNumber)
12431 
      oprot.writeFieldEnd()
4602 rajveer 12432 
    if self.providerId is not None:
12433 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12434 
      oprot.writeI64(self.providerId)
12435 
      oprot.writeFieldEnd()
2536 chandransh 12436 
    oprot.writeFieldStop()
12437 
    oprot.writeStructEnd()
12438 
 
3431 rajveer 12439 
  def validate(self):
12440 
    return
12441 
 
12442 
 
2536 chandransh 12443 
  def __repr__(self):
12444 
    L = ['%s=%r' % (key, value)
12445 
      for key, value in self.__dict__.iteritems()]
12446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12447 
 
12448 
  def __eq__(self, other):
12449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12450 
 
12451 
  def __ne__(self, other):
12452 
    return not (self == other)
12453 
 
12454 
class authorizePickup_result:
12455 
  """
12456 
  Attributes:
12457 
   - success
12458 
   - ex
12459 
  """
12460 
 
12461 
  thrift_spec = (
12462 
    (0, TType.BOOL, 'success', None, None, ), # 0
12463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12464 
  )
12465 
 
12466 
  def __init__(self, success=None, ex=None,):
12467 
    self.success = success
12468 
    self.ex = ex
12469 
 
12470 
  def read(self, iprot):
12471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12473 
      return
12474 
    iprot.readStructBegin()
12475 
    while True:
12476 
      (fname, ftype, fid) = iprot.readFieldBegin()
12477 
      if ftype == TType.STOP:
12478 
        break
12479 
      if fid == 0:
12480 
        if ftype == TType.BOOL:
12481 
          self.success = iprot.readBool();
12482 
        else:
12483 
          iprot.skip(ftype)
12484 
      elif fid == 1:
12485 
        if ftype == TType.STRUCT:
12486 
          self.ex = TransactionServiceException()
12487 
          self.ex.read(iprot)
12488 
        else:
12489 
          iprot.skip(ftype)
12490 
      else:
12491 
        iprot.skip(ftype)
12492 
      iprot.readFieldEnd()
12493 
    iprot.readStructEnd()
12494 
 
12495 
  def write(self, oprot):
12496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12498 
      return
12499 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12500 
    if self.success is not None:
2536 chandransh 12501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12502 
      oprot.writeBool(self.success)
12503 
      oprot.writeFieldEnd()
3431 rajveer 12504 
    if self.ex is not None:
2536 chandransh 12505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12506 
      self.ex.write(oprot)
12507 
      oprot.writeFieldEnd()
12508 
    oprot.writeFieldStop()
12509 
    oprot.writeStructEnd()
12510 
 
3431 rajveer 12511 
  def validate(self):
12512 
    return
12513 
 
12514 
 
2536 chandransh 12515 
  def __repr__(self):
12516 
    L = ['%s=%r' % (key, value)
12517 
      for key, value in self.__dict__.iteritems()]
12518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12519 
 
12520 
  def __eq__(self, other):
12521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12522 
 
12523 
  def __ne__(self, other):
12524 
    return not (self == other)
12525 
 
2764 chandransh 12526 
class markDoasAsPickedUp_args:
12527 
  """
12528 
  Attributes:
12529 
   - providerId
12530 
   - pickupDetails
12531 
  """
12532 
 
12533 
  thrift_spec = (
12534 
    None, # 0
12535 
    (1, TType.I64, 'providerId', None, None, ), # 1
12536 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12537 
  )
12538 
 
12539 
  def __init__(self, providerId=None, pickupDetails=None,):
12540 
    self.providerId = providerId
12541 
    self.pickupDetails = pickupDetails
12542 
 
12543 
  def read(self, iprot):
12544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12546 
      return
12547 
    iprot.readStructBegin()
12548 
    while True:
12549 
      (fname, ftype, fid) = iprot.readFieldBegin()
12550 
      if ftype == TType.STOP:
12551 
        break
12552 
      if fid == 1:
12553 
        if ftype == TType.I64:
12554 
          self.providerId = iprot.readI64();
12555 
        else:
12556 
          iprot.skip(ftype)
12557 
      elif fid == 2:
12558 
        if ftype == TType.MAP:
12559 
          self.pickupDetails = {}
4581 phani.kuma 12560 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12561 
          for _i201 in xrange(_size197):
12562 
            _key202 = iprot.readString();
12563 
            _val203 = iprot.readString();
12564 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12565 
          iprot.readMapEnd()
12566 
        else:
12567 
          iprot.skip(ftype)
12568 
      else:
12569 
        iprot.skip(ftype)
12570 
      iprot.readFieldEnd()
12571 
    iprot.readStructEnd()
12572 
 
12573 
  def write(self, oprot):
12574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12576 
      return
12577 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12578 
    if self.providerId is not None:
2764 chandransh 12579 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12580 
      oprot.writeI64(self.providerId)
12581 
      oprot.writeFieldEnd()
3431 rajveer 12582 
    if self.pickupDetails is not None:
2764 chandransh 12583 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12584 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12585 
      for kiter204,viter205 in self.pickupDetails.items():
12586 
        oprot.writeString(kiter204)
12587 
        oprot.writeString(viter205)
2764 chandransh 12588 
      oprot.writeMapEnd()
12589 
      oprot.writeFieldEnd()
12590 
    oprot.writeFieldStop()
12591 
    oprot.writeStructEnd()
12592 
 
3431 rajveer 12593 
  def validate(self):
12594 
    return
12595 
 
12596 
 
2764 chandransh 12597 
  def __repr__(self):
12598 
    L = ['%s=%r' % (key, value)
12599 
      for key, value in self.__dict__.iteritems()]
12600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12601 
 
12602 
  def __eq__(self, other):
12603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12604 
 
12605 
  def __ne__(self, other):
12606 
    return not (self == other)
12607 
 
12608 
class markDoasAsPickedUp_result:
12609 
  """
12610 
  Attributes:
12611 
   - success
12612 
  """
12613 
 
12614 
  thrift_spec = (
12615 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12616 
  )
12617 
 
12618 
  def __init__(self, success=None,):
12619 
    self.success = success
12620 
 
12621 
  def read(self, iprot):
12622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12624 
      return
12625 
    iprot.readStructBegin()
12626 
    while True:
12627 
      (fname, ftype, fid) = iprot.readFieldBegin()
12628 
      if ftype == TType.STOP:
12629 
        break
12630 
      if fid == 0:
12631 
        if ftype == TType.LIST:
12632 
          self.success = []
4581 phani.kuma 12633 
          (_etype209, _size206) = iprot.readListBegin()
12634 
          for _i210 in xrange(_size206):
12635 
            _elem211 = Order()
12636 
            _elem211.read(iprot)
12637 
            self.success.append(_elem211)
2764 chandransh 12638 
          iprot.readListEnd()
12639 
        else:
12640 
          iprot.skip(ftype)
12641 
      else:
12642 
        iprot.skip(ftype)
12643 
      iprot.readFieldEnd()
12644 
    iprot.readStructEnd()
12645 
 
12646 
  def write(self, oprot):
12647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12649 
      return
12650 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12651 
    if self.success is not None:
2764 chandransh 12652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12654 
      for iter212 in self.success:
12655 
        iter212.write(oprot)
2764 chandransh 12656 
      oprot.writeListEnd()
12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
3431 rajveer 12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
2764 chandransh 12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
2616 chandransh 12676 
class receiveReturn_args:
2591 chandransh 12677 
  """
12678 
  Attributes:
12679 
   - orderId
4479 rajveer 12680 
   - receiveCondition
2591 chandransh 12681 
  """
2536 chandransh 12682 
 
2591 chandransh 12683 
  thrift_spec = (
12684 
    None, # 0
12685 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12686 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12687 
  )
12688 
 
4479 rajveer 12689 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12690 
    self.orderId = orderId
4479 rajveer 12691 
    self.receiveCondition = receiveCondition
2591 chandransh 12692 
 
12693 
  def read(self, iprot):
12694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12696 
      return
12697 
    iprot.readStructBegin()
12698 
    while True:
12699 
      (fname, ftype, fid) = iprot.readFieldBegin()
12700 
      if ftype == TType.STOP:
12701 
        break
12702 
      if fid == 1:
12703 
        if ftype == TType.I64:
12704 
          self.orderId = iprot.readI64();
12705 
        else:
12706 
          iprot.skip(ftype)
4479 rajveer 12707 
      elif fid == 2:
12708 
        if ftype == TType.I64:
12709 
          self.receiveCondition = iprot.readI64();
12710 
        else:
12711 
          iprot.skip(ftype)
2591 chandransh 12712 
      else:
12713 
        iprot.skip(ftype)
12714 
      iprot.readFieldEnd()
12715 
    iprot.readStructEnd()
12716 
 
12717 
  def write(self, oprot):
12718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12720 
      return
2616 chandransh 12721 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12722 
    if self.orderId is not None:
2591 chandransh 12723 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12724 
      oprot.writeI64(self.orderId)
12725 
      oprot.writeFieldEnd()
4479 rajveer 12726 
    if self.receiveCondition is not None:
12727 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12728 
      oprot.writeI64(self.receiveCondition)
12729 
      oprot.writeFieldEnd()
2591 chandransh 12730 
    oprot.writeFieldStop()
12731 
    oprot.writeStructEnd()
12732 
 
3431 rajveer 12733 
  def validate(self):
12734 
    return
12735 
 
12736 
 
2591 chandransh 12737 
  def __repr__(self):
12738 
    L = ['%s=%r' % (key, value)
12739 
      for key, value in self.__dict__.iteritems()]
12740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12741 
 
12742 
  def __eq__(self, other):
12743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12744 
 
12745 
  def __ne__(self, other):
12746 
    return not (self == other)
12747 
 
2616 chandransh 12748 
class receiveReturn_result:
2591 chandransh 12749 
  """
12750 
  Attributes:
12751 
   - success
12752 
   - ex
12753 
  """
12754 
 
12755 
  thrift_spec = (
12756 
    (0, TType.BOOL, 'success', None, None, ), # 0
12757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12758 
  )
12759 
 
12760 
  def __init__(self, success=None, ex=None,):
12761 
    self.success = success
12762 
    self.ex = ex
12763 
 
12764 
  def read(self, iprot):
12765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12767 
      return
12768 
    iprot.readStructBegin()
12769 
    while True:
12770 
      (fname, ftype, fid) = iprot.readFieldBegin()
12771 
      if ftype == TType.STOP:
12772 
        break
12773 
      if fid == 0:
12774 
        if ftype == TType.BOOL:
12775 
          self.success = iprot.readBool();
12776 
        else:
12777 
          iprot.skip(ftype)
12778 
      elif fid == 1:
12779 
        if ftype == TType.STRUCT:
12780 
          self.ex = TransactionServiceException()
12781 
          self.ex.read(iprot)
12782 
        else:
12783 
          iprot.skip(ftype)
12784 
      else:
12785 
        iprot.skip(ftype)
12786 
      iprot.readFieldEnd()
12787 
    iprot.readStructEnd()
12788 
 
12789 
  def write(self, oprot):
12790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12792 
      return
2616 chandransh 12793 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12794 
    if self.success is not None:
2591 chandransh 12795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12796 
      oprot.writeBool(self.success)
12797 
      oprot.writeFieldEnd()
3431 rajveer 12798 
    if self.ex is not None:
2591 chandransh 12799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12800 
      self.ex.write(oprot)
12801 
      oprot.writeFieldEnd()
12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
3431 rajveer 12805 
  def validate(self):
12806 
    return
12807 
 
12808 
 
2591 chandransh 12809 
  def __repr__(self):
12810 
    L = ['%s=%r' % (key, value)
12811 
      for key, value in self.__dict__.iteritems()]
12812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12813 
 
12814 
  def __eq__(self, other):
12815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12816 
 
12817 
  def __ne__(self, other):
12818 
    return not (self == other)
12819 
 
12820 
class validateDoa_args:
12821 
  """
12822 
  Attributes:
12823 
   - orderId
12824 
   - isValid
12825 
  """
12826 
 
12827 
  thrift_spec = (
12828 
    None, # 0
12829 
    (1, TType.I64, 'orderId', None, None, ), # 1
12830 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12831 
  )
12832 
 
12833 
  def __init__(self, orderId=None, isValid=None,):
12834 
    self.orderId = orderId
12835 
    self.isValid = isValid
12836 
 
12837 
  def read(self, iprot):
12838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12840 
      return
12841 
    iprot.readStructBegin()
12842 
    while True:
12843 
      (fname, ftype, fid) = iprot.readFieldBegin()
12844 
      if ftype == TType.STOP:
12845 
        break
12846 
      if fid == 1:
12847 
        if ftype == TType.I64:
12848 
          self.orderId = iprot.readI64();
12849 
        else:
12850 
          iprot.skip(ftype)
12851 
      elif fid == 2:
12852 
        if ftype == TType.BOOL:
12853 
          self.isValid = iprot.readBool();
12854 
        else:
12855 
          iprot.skip(ftype)
12856 
      else:
12857 
        iprot.skip(ftype)
12858 
      iprot.readFieldEnd()
12859 
    iprot.readStructEnd()
12860 
 
12861 
  def write(self, oprot):
12862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12864 
      return
12865 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12866 
    if self.orderId is not None:
2591 chandransh 12867 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12868 
      oprot.writeI64(self.orderId)
12869 
      oprot.writeFieldEnd()
3431 rajveer 12870 
    if self.isValid is not None:
2591 chandransh 12871 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12872 
      oprot.writeBool(self.isValid)
12873 
      oprot.writeFieldEnd()
12874 
    oprot.writeFieldStop()
12875 
    oprot.writeStructEnd()
12876 
 
3431 rajveer 12877 
  def validate(self):
12878 
    return
12879 
 
12880 
 
2591 chandransh 12881 
  def __repr__(self):
12882 
    L = ['%s=%r' % (key, value)
12883 
      for key, value in self.__dict__.iteritems()]
12884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12885 
 
12886 
  def __eq__(self, other):
12887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12888 
 
12889 
  def __ne__(self, other):
12890 
    return not (self == other)
12891 
 
12892 
class validateDoa_result:
12893 
  """
12894 
  Attributes:
12895 
   - success
12896 
   - ex
12897 
  """
12898 
 
12899 
  thrift_spec = (
12900 
    (0, TType.BOOL, 'success', None, None, ), # 0
12901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12902 
  )
12903 
 
12904 
  def __init__(self, success=None, ex=None,):
12905 
    self.success = success
12906 
    self.ex = ex
12907 
 
12908 
  def read(self, iprot):
12909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12911 
      return
12912 
    iprot.readStructBegin()
12913 
    while True:
12914 
      (fname, ftype, fid) = iprot.readFieldBegin()
12915 
      if ftype == TType.STOP:
12916 
        break
12917 
      if fid == 0:
12918 
        if ftype == TType.BOOL:
12919 
          self.success = iprot.readBool();
12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      elif fid == 1:
12923 
        if ftype == TType.STRUCT:
12924 
          self.ex = TransactionServiceException()
12925 
          self.ex.read(iprot)
12926 
        else:
12927 
          iprot.skip(ftype)
12928 
      else:
12929 
        iprot.skip(ftype)
12930 
      iprot.readFieldEnd()
12931 
    iprot.readStructEnd()
12932 
 
12933 
  def write(self, oprot):
12934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12936 
      return
12937 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12938 
    if self.success is not None:
2591 chandransh 12939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12940 
      oprot.writeBool(self.success)
12941 
      oprot.writeFieldEnd()
3431 rajveer 12942 
    if self.ex is not None:
2591 chandransh 12943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12944 
      self.ex.write(oprot)
12945 
      oprot.writeFieldEnd()
12946 
    oprot.writeFieldStop()
12947 
    oprot.writeStructEnd()
12948 
 
3431 rajveer 12949 
  def validate(self):
12950 
    return
12951 
 
12952 
 
2591 chandransh 12953 
  def __repr__(self):
12954 
    L = ['%s=%r' % (key, value)
12955 
      for key, value in self.__dict__.iteritems()]
12956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12957 
 
12958 
  def __eq__(self, other):
12959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12960 
 
12961 
  def __ne__(self, other):
12962 
    return not (self == other)
12963 
 
4495 rajveer 12964 
class validateReturnProduct_args:
12965 
  """
12966 
  Attributes:
12967 
   - orderId
12968 
   - isUsable
12969 
  """
12970 
 
12971 
  thrift_spec = (
12972 
    None, # 0
12973 
    (1, TType.I64, 'orderId', None, None, ), # 1
12974 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12975 
  )
12976 
 
12977 
  def __init__(self, orderId=None, isUsable=None,):
12978 
    self.orderId = orderId
12979 
    self.isUsable = isUsable
12980 
 
12981 
  def read(self, iprot):
12982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12984 
      return
12985 
    iprot.readStructBegin()
12986 
    while True:
12987 
      (fname, ftype, fid) = iprot.readFieldBegin()
12988 
      if ftype == TType.STOP:
12989 
        break
12990 
      if fid == 1:
12991 
        if ftype == TType.I64:
12992 
          self.orderId = iprot.readI64();
12993 
        else:
12994 
          iprot.skip(ftype)
12995 
      elif fid == 2:
12996 
        if ftype == TType.BOOL:
12997 
          self.isUsable = iprot.readBool();
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('validateReturnProduct_args')
13010 
    if self.orderId is not None:
13011 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13012 
      oprot.writeI64(self.orderId)
13013 
      oprot.writeFieldEnd()
13014 
    if self.isUsable is not None:
13015 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13016 
      oprot.writeBool(self.isUsable)
13017 
      oprot.writeFieldEnd()
13018 
    oprot.writeFieldStop()
13019 
    oprot.writeStructEnd()
13020 
 
13021 
  def validate(self):
13022 
    return
13023 
 
13024 
 
13025 
  def __repr__(self):
13026 
    L = ['%s=%r' % (key, value)
13027 
      for key, value in self.__dict__.iteritems()]
13028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13029 
 
13030 
  def __eq__(self, other):
13031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13032 
 
13033 
  def __ne__(self, other):
13034 
    return not (self == other)
13035 
 
13036 
class validateReturnProduct_result:
13037 
  """
13038 
  Attributes:
13039 
   - success
13040 
   - ex
13041 
  """
13042 
 
13043 
  thrift_spec = (
13044 
    (0, TType.BOOL, 'success', None, None, ), # 0
13045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13046 
  )
13047 
 
13048 
  def __init__(self, success=None, ex=None,):
13049 
    self.success = success
13050 
    self.ex = ex
13051 
 
13052 
  def read(self, iprot):
13053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13055 
      return
13056 
    iprot.readStructBegin()
13057 
    while True:
13058 
      (fname, ftype, fid) = iprot.readFieldBegin()
13059 
      if ftype == TType.STOP:
13060 
        break
13061 
      if fid == 0:
13062 
        if ftype == TType.BOOL:
13063 
          self.success = iprot.readBool();
13064 
        else:
13065 
          iprot.skip(ftype)
13066 
      elif fid == 1:
13067 
        if ftype == TType.STRUCT:
13068 
          self.ex = TransactionServiceException()
13069 
          self.ex.read(iprot)
13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
13081 
    oprot.writeStructBegin('validateReturnProduct_result')
13082 
    if self.success is not None:
13083 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13084 
      oprot.writeBool(self.success)
13085 
      oprot.writeFieldEnd()
13086 
    if self.ex is not None:
13087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13088 
      self.ex.write(oprot)
13089 
      oprot.writeFieldEnd()
13090 
    oprot.writeFieldStop()
13091 
    oprot.writeStructEnd()
13092 
 
13093 
  def validate(self):
13094 
    return
13095 
 
13096 
 
13097 
  def __repr__(self):
13098 
    L = ['%s=%r' % (key, value)
13099 
      for key, value in self.__dict__.iteritems()]
13100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13101 
 
13102 
  def __eq__(self, other):
13103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13104 
 
13105 
  def __ne__(self, other):
13106 
    return not (self == other)
13107 
 
2616 chandransh 13108 
class reshipOrder_args:
13109 
  """
13110 
  Attributes:
13111 
   - orderId
13112 
  """
2591 chandransh 13113 
 
2616 chandransh 13114 
  thrift_spec = (
13115 
    None, # 0
13116 
    (1, TType.I64, 'orderId', None, None, ), # 1
13117 
  )
13118 
 
13119 
  def __init__(self, orderId=None,):
13120 
    self.orderId = orderId
13121 
 
13122 
  def read(self, iprot):
13123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13125 
      return
13126 
    iprot.readStructBegin()
13127 
    while True:
13128 
      (fname, ftype, fid) = iprot.readFieldBegin()
13129 
      if ftype == TType.STOP:
13130 
        break
13131 
      if fid == 1:
13132 
        if ftype == TType.I64:
13133 
          self.orderId = iprot.readI64();
13134 
        else:
13135 
          iprot.skip(ftype)
13136 
      else:
13137 
        iprot.skip(ftype)
13138 
      iprot.readFieldEnd()
13139 
    iprot.readStructEnd()
13140 
 
13141 
  def write(self, oprot):
13142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13144 
      return
13145 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13146 
    if self.orderId is not None:
2616 chandransh 13147 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13148 
      oprot.writeI64(self.orderId)
13149 
      oprot.writeFieldEnd()
13150 
    oprot.writeFieldStop()
13151 
    oprot.writeStructEnd()
13152 
 
3431 rajveer 13153 
  def validate(self):
13154 
    return
13155 
 
13156 
 
2616 chandransh 13157 
  def __repr__(self):
13158 
    L = ['%s=%r' % (key, value)
13159 
      for key, value in self.__dict__.iteritems()]
13160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13161 
 
13162 
  def __eq__(self, other):
13163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13164 
 
13165 
  def __ne__(self, other):
13166 
    return not (self == other)
13167 
 
13168 
class reshipOrder_result:
13169 
  """
13170 
  Attributes:
13171 
   - success
13172 
   - ex
13173 
  """
13174 
 
13175 
  thrift_spec = (
13176 
    (0, TType.I64, 'success', None, None, ), # 0
13177 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13178 
  )
13179 
 
13180 
  def __init__(self, success=None, ex=None,):
13181 
    self.success = success
13182 
    self.ex = ex
13183 
 
13184 
  def read(self, iprot):
13185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13187 
      return
13188 
    iprot.readStructBegin()
13189 
    while True:
13190 
      (fname, ftype, fid) = iprot.readFieldBegin()
13191 
      if ftype == TType.STOP:
13192 
        break
13193 
      if fid == 0:
13194 
        if ftype == TType.I64:
13195 
          self.success = iprot.readI64();
13196 
        else:
13197 
          iprot.skip(ftype)
13198 
      elif fid == 1:
13199 
        if ftype == TType.STRUCT:
13200 
          self.ex = TransactionServiceException()
13201 
          self.ex.read(iprot)
13202 
        else:
13203 
          iprot.skip(ftype)
13204 
      else:
13205 
        iprot.skip(ftype)
13206 
      iprot.readFieldEnd()
13207 
    iprot.readStructEnd()
13208 
 
13209 
  def write(self, oprot):
13210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13212 
      return
13213 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13214 
    if self.success is not None:
2616 chandransh 13215 
      oprot.writeFieldBegin('success', TType.I64, 0)
13216 
      oprot.writeI64(self.success)
13217 
      oprot.writeFieldEnd()
3431 rajveer 13218 
    if self.ex is not None:
2616 chandransh 13219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13220 
      self.ex.write(oprot)
13221 
      oprot.writeFieldEnd()
13222 
    oprot.writeFieldStop()
13223 
    oprot.writeStructEnd()
13224 
 
3431 rajveer 13225 
  def validate(self):
13226 
    return
13227 
 
13228 
 
2616 chandransh 13229 
  def __repr__(self):
13230 
    L = ['%s=%r' % (key, value)
13231 
      for key, value in self.__dict__.iteritems()]
13232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13233 
 
13234 
  def __eq__(self, other):
13235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13236 
 
13237 
  def __ne__(self, other):
13238 
    return not (self == other)
13239 
 
13240 
class refundOrder_args:
13241 
  """
13242 
  Attributes:
13243 
   - orderId
3226 chandransh 13244 
   - refundedBy
13245 
   - reason
2616 chandransh 13246 
  """
13247 
 
13248 
  thrift_spec = (
13249 
    None, # 0
13250 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13251 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13252 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13253 
  )
13254 
 
3226 chandransh 13255 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13256 
    self.orderId = orderId
3226 chandransh 13257 
    self.refundedBy = refundedBy
13258 
    self.reason = reason
2616 chandransh 13259 
 
13260 
  def read(self, iprot):
13261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13263 
      return
13264 
    iprot.readStructBegin()
13265 
    while True:
13266 
      (fname, ftype, fid) = iprot.readFieldBegin()
13267 
      if ftype == TType.STOP:
13268 
        break
13269 
      if fid == 1:
13270 
        if ftype == TType.I64:
13271 
          self.orderId = iprot.readI64();
13272 
        else:
13273 
          iprot.skip(ftype)
3226 chandransh 13274 
      elif fid == 2:
13275 
        if ftype == TType.STRING:
13276 
          self.refundedBy = iprot.readString();
13277 
        else:
13278 
          iprot.skip(ftype)
13279 
      elif fid == 3:
13280 
        if ftype == TType.STRING:
13281 
          self.reason = iprot.readString();
13282 
        else:
13283 
          iprot.skip(ftype)
2616 chandransh 13284 
      else:
13285 
        iprot.skip(ftype)
13286 
      iprot.readFieldEnd()
13287 
    iprot.readStructEnd()
13288 
 
13289 
  def write(self, oprot):
13290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13292 
      return
13293 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13294 
    if self.orderId is not None:
2616 chandransh 13295 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13296 
      oprot.writeI64(self.orderId)
13297 
      oprot.writeFieldEnd()
3431 rajveer 13298 
    if self.refundedBy is not None:
3226 chandransh 13299 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13300 
      oprot.writeString(self.refundedBy)
13301 
      oprot.writeFieldEnd()
3431 rajveer 13302 
    if self.reason is not None:
3226 chandransh 13303 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13304 
      oprot.writeString(self.reason)
13305 
      oprot.writeFieldEnd()
2616 chandransh 13306 
    oprot.writeFieldStop()
13307 
    oprot.writeStructEnd()
13308 
 
3431 rajveer 13309 
  def validate(self):
13310 
    return
13311 
 
13312 
 
2616 chandransh 13313 
  def __repr__(self):
13314 
    L = ['%s=%r' % (key, value)
13315 
      for key, value in self.__dict__.iteritems()]
13316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13317 
 
13318 
  def __eq__(self, other):
13319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13320 
 
13321 
  def __ne__(self, other):
13322 
    return not (self == other)
13323 
 
13324 
class refundOrder_result:
13325 
  """
13326 
  Attributes:
13327 
   - success
13328 
   - ex
13329 
  """
13330 
 
13331 
  thrift_spec = (
13332 
    (0, TType.BOOL, 'success', None, None, ), # 0
13333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13334 
  )
13335 
 
13336 
  def __init__(self, success=None, ex=None,):
13337 
    self.success = success
13338 
    self.ex = ex
13339 
 
13340 
  def read(self, iprot):
13341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13343 
      return
13344 
    iprot.readStructBegin()
13345 
    while True:
13346 
      (fname, ftype, fid) = iprot.readFieldBegin()
13347 
      if ftype == TType.STOP:
13348 
        break
13349 
      if fid == 0:
13350 
        if ftype == TType.BOOL:
13351 
          self.success = iprot.readBool();
13352 
        else:
13353 
          iprot.skip(ftype)
13354 
      elif fid == 1:
13355 
        if ftype == TType.STRUCT:
13356 
          self.ex = TransactionServiceException()
13357 
          self.ex.read(iprot)
13358 
        else:
13359 
          iprot.skip(ftype)
13360 
      else:
13361 
        iprot.skip(ftype)
13362 
      iprot.readFieldEnd()
13363 
    iprot.readStructEnd()
13364 
 
13365 
  def write(self, oprot):
13366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13368 
      return
13369 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13370 
    if self.success is not None:
2616 chandransh 13371 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13372 
      oprot.writeBool(self.success)
13373 
      oprot.writeFieldEnd()
3431 rajveer 13374 
    if self.ex is not None:
2616 chandransh 13375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13376 
      self.ex.write(oprot)
13377 
      oprot.writeFieldEnd()
13378 
    oprot.writeFieldStop()
13379 
    oprot.writeStructEnd()
13380 
 
3431 rajveer 13381 
  def validate(self):
13382 
    return
13383 
 
13384 
 
2616 chandransh 13385 
  def __repr__(self):
13386 
    L = ['%s=%r' % (key, value)
13387 
      for key, value in self.__dict__.iteritems()]
13388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13389 
 
13390 
  def __eq__(self, other):
13391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13392 
 
13393 
  def __ne__(self, other):
13394 
    return not (self == other)
13395 
 
2690 chandransh 13396 
class getReturnOrders_args:
13397 
  """
13398 
  Attributes:
13399 
   - warehouseId
13400 
   - fromDate
13401 
   - toDate
13402 
  """
2616 chandransh 13403 
 
2690 chandransh 13404 
  thrift_spec = (
13405 
    None, # 0
13406 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13407 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13408 
    (3, TType.I64, 'toDate', None, None, ), # 3
13409 
  )
13410 
 
13411 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13412 
    self.warehouseId = warehouseId
13413 
    self.fromDate = fromDate
13414 
    self.toDate = toDate
13415 
 
13416 
  def read(self, iprot):
13417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13419 
      return
13420 
    iprot.readStructBegin()
13421 
    while True:
13422 
      (fname, ftype, fid) = iprot.readFieldBegin()
13423 
      if ftype == TType.STOP:
13424 
        break
13425 
      if fid == 1:
13426 
        if ftype == TType.I64:
13427 
          self.warehouseId = iprot.readI64();
13428 
        else:
13429 
          iprot.skip(ftype)
13430 
      elif fid == 2:
13431 
        if ftype == TType.I64:
13432 
          self.fromDate = iprot.readI64();
13433 
        else:
13434 
          iprot.skip(ftype)
13435 
      elif fid == 3:
13436 
        if ftype == TType.I64:
13437 
          self.toDate = iprot.readI64();
13438 
        else:
13439 
          iprot.skip(ftype)
13440 
      else:
13441 
        iprot.skip(ftype)
13442 
      iprot.readFieldEnd()
13443 
    iprot.readStructEnd()
13444 
 
13445 
  def write(self, oprot):
13446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13448 
      return
13449 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13450 
    if self.warehouseId is not None:
2690 chandransh 13451 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13452 
      oprot.writeI64(self.warehouseId)
13453 
      oprot.writeFieldEnd()
3431 rajveer 13454 
    if self.fromDate is not None:
2690 chandransh 13455 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13456 
      oprot.writeI64(self.fromDate)
13457 
      oprot.writeFieldEnd()
3431 rajveer 13458 
    if self.toDate is not None:
2690 chandransh 13459 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13460 
      oprot.writeI64(self.toDate)
13461 
      oprot.writeFieldEnd()
13462 
    oprot.writeFieldStop()
13463 
    oprot.writeStructEnd()
13464 
 
3431 rajveer 13465 
  def validate(self):
13466 
    return
13467 
 
13468 
 
2690 chandransh 13469 
  def __repr__(self):
13470 
    L = ['%s=%r' % (key, value)
13471 
      for key, value in self.__dict__.iteritems()]
13472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13473 
 
13474 
  def __eq__(self, other):
13475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13476 
 
13477 
  def __ne__(self, other):
13478 
    return not (self == other)
13479 
 
13480 
class getReturnOrders_result:
13481 
  """
13482 
  Attributes:
13483 
   - success
13484 
  """
13485 
 
13486 
  thrift_spec = (
13487 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13488 
  )
13489 
 
13490 
  def __init__(self, success=None,):
13491 
    self.success = success
13492 
 
13493 
  def read(self, iprot):
13494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13496 
      return
13497 
    iprot.readStructBegin()
13498 
    while True:
13499 
      (fname, ftype, fid) = iprot.readFieldBegin()
13500 
      if ftype == TType.STOP:
13501 
        break
13502 
      if fid == 0:
13503 
        if ftype == TType.LIST:
13504 
          self.success = []
4581 phani.kuma 13505 
          (_etype216, _size213) = iprot.readListBegin()
13506 
          for _i217 in xrange(_size213):
13507 
            _elem218 = ReturnOrder()
13508 
            _elem218.read(iprot)
13509 
            self.success.append(_elem218)
2690 chandransh 13510 
          iprot.readListEnd()
13511 
        else:
13512 
          iprot.skip(ftype)
13513 
      else:
13514 
        iprot.skip(ftype)
13515 
      iprot.readFieldEnd()
13516 
    iprot.readStructEnd()
13517 
 
13518 
  def write(self, oprot):
13519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13521 
      return
13522 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13523 
    if self.success is not None:
2690 chandransh 13524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13526 
      for iter219 in self.success:
13527 
        iter219.write(oprot)
2690 chandransh 13528 
      oprot.writeListEnd()
13529 
      oprot.writeFieldEnd()
13530 
    oprot.writeFieldStop()
13531 
    oprot.writeStructEnd()
13532 
 
3431 rajveer 13533 
  def validate(self):
13534 
    return
13535 
 
13536 
 
2690 chandransh 13537 
  def __repr__(self):
13538 
    L = ['%s=%r' % (key, value)
13539 
      for key, value in self.__dict__.iteritems()]
13540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13541 
 
13542 
  def __eq__(self, other):
13543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13544 
 
13545 
  def __ne__(self, other):
13546 
    return not (self == other)
13547 
 
2700 chandransh 13548 
class getReturnOrder_args:
13549 
  """
13550 
  Attributes:
13551 
   - id
13552 
  """
13553 
 
13554 
  thrift_spec = (
13555 
    None, # 0
13556 
    (1, TType.I64, 'id', None, None, ), # 1
13557 
  )
13558 
 
13559 
  def __init__(self, id=None,):
13560 
    self.id = id
13561 
 
13562 
  def read(self, iprot):
13563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13565 
      return
13566 
    iprot.readStructBegin()
13567 
    while True:
13568 
      (fname, ftype, fid) = iprot.readFieldBegin()
13569 
      if ftype == TType.STOP:
13570 
        break
13571 
      if fid == 1:
13572 
        if ftype == TType.I64:
13573 
          self.id = iprot.readI64();
13574 
        else:
13575 
          iprot.skip(ftype)
13576 
      else:
13577 
        iprot.skip(ftype)
13578 
      iprot.readFieldEnd()
13579 
    iprot.readStructEnd()
13580 
 
13581 
  def write(self, oprot):
13582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13584 
      return
13585 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13586 
    if self.id is not None:
2700 chandransh 13587 
      oprot.writeFieldBegin('id', TType.I64, 1)
13588 
      oprot.writeI64(self.id)
13589 
      oprot.writeFieldEnd()
13590 
    oprot.writeFieldStop()
13591 
    oprot.writeStructEnd()
13592 
 
3431 rajveer 13593 
  def validate(self):
13594 
    return
13595 
 
13596 
 
2700 chandransh 13597 
  def __repr__(self):
13598 
    L = ['%s=%r' % (key, value)
13599 
      for key, value in self.__dict__.iteritems()]
13600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13601 
 
13602 
  def __eq__(self, other):
13603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13604 
 
13605 
  def __ne__(self, other):
13606 
    return not (self == other)
13607 
 
13608 
class getReturnOrder_result:
13609 
  """
13610 
  Attributes:
13611 
   - success
13612 
   - ex
13613 
  """
13614 
 
13615 
  thrift_spec = (
13616 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13618 
  )
13619 
 
13620 
  def __init__(self, success=None, ex=None,):
13621 
    self.success = success
13622 
    self.ex = ex
13623 
 
13624 
  def read(self, iprot):
13625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13627 
      return
13628 
    iprot.readStructBegin()
13629 
    while True:
13630 
      (fname, ftype, fid) = iprot.readFieldBegin()
13631 
      if ftype == TType.STOP:
13632 
        break
13633 
      if fid == 0:
13634 
        if ftype == TType.STRUCT:
13635 
          self.success = ReturnOrder()
13636 
          self.success.read(iprot)
13637 
        else:
13638 
          iprot.skip(ftype)
13639 
      elif fid == 1:
13640 
        if ftype == TType.STRUCT:
13641 
          self.ex = TransactionServiceException()
13642 
          self.ex.read(iprot)
13643 
        else:
13644 
          iprot.skip(ftype)
13645 
      else:
13646 
        iprot.skip(ftype)
13647 
      iprot.readFieldEnd()
13648 
    iprot.readStructEnd()
13649 
 
13650 
  def write(self, oprot):
13651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13653 
      return
13654 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13655 
    if self.success is not None:
2700 chandransh 13656 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13657 
      self.success.write(oprot)
13658 
      oprot.writeFieldEnd()
3431 rajveer 13659 
    if self.ex is not None:
2700 chandransh 13660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13661 
      self.ex.write(oprot)
13662 
      oprot.writeFieldEnd()
13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
3431 rajveer 13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
2700 chandransh 13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
2690 chandransh 13681 
class processReturn_args:
13682 
  """
13683 
  Attributes:
13684 
   - returnOrderId
13685 
  """
13686 
 
13687 
  thrift_spec = (
13688 
    None, # 0
13689 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13690 
  )
13691 
 
13692 
  def __init__(self, returnOrderId=None,):
13693 
    self.returnOrderId = returnOrderId
13694 
 
13695 
  def read(self, iprot):
13696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13698 
      return
13699 
    iprot.readStructBegin()
13700 
    while True:
13701 
      (fname, ftype, fid) = iprot.readFieldBegin()
13702 
      if ftype == TType.STOP:
13703 
        break
13704 
      if fid == 1:
13705 
        if ftype == TType.I64:
13706 
          self.returnOrderId = iprot.readI64();
13707 
        else:
13708 
          iprot.skip(ftype)
13709 
      else:
13710 
        iprot.skip(ftype)
13711 
      iprot.readFieldEnd()
13712 
    iprot.readStructEnd()
13713 
 
13714 
  def write(self, oprot):
13715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13717 
      return
13718 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13719 
    if self.returnOrderId is not None:
2690 chandransh 13720 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13721 
      oprot.writeI64(self.returnOrderId)
13722 
      oprot.writeFieldEnd()
13723 
    oprot.writeFieldStop()
13724 
    oprot.writeStructEnd()
13725 
 
3431 rajveer 13726 
  def validate(self):
13727 
    return
13728 
 
13729 
 
2690 chandransh 13730 
  def __repr__(self):
13731 
    L = ['%s=%r' % (key, value)
13732 
      for key, value in self.__dict__.iteritems()]
13733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13734 
 
13735 
  def __eq__(self, other):
13736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13737 
 
13738 
  def __ne__(self, other):
13739 
    return not (self == other)
13740 
 
13741 
class processReturn_result:
13742 
  """
13743 
  Attributes:
13744 
   - ex
13745 
  """
13746 
 
13747 
  thrift_spec = (
13748 
    None, # 0
13749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13750 
  )
13751 
 
13752 
  def __init__(self, ex=None,):
13753 
    self.ex = ex
13754 
 
13755 
  def read(self, iprot):
13756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13758 
      return
13759 
    iprot.readStructBegin()
13760 
    while True:
13761 
      (fname, ftype, fid) = iprot.readFieldBegin()
13762 
      if ftype == TType.STOP:
13763 
        break
13764 
      if fid == 1:
13765 
        if ftype == TType.STRUCT:
13766 
          self.ex = TransactionServiceException()
13767 
          self.ex.read(iprot)
13768 
        else:
13769 
          iprot.skip(ftype)
13770 
      else:
13771 
        iprot.skip(ftype)
13772 
      iprot.readFieldEnd()
13773 
    iprot.readStructEnd()
13774 
 
13775 
  def write(self, oprot):
13776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13778 
      return
13779 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13780 
    if self.ex is not None:
2690 chandransh 13781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13782 
      self.ex.write(oprot)
13783 
      oprot.writeFieldEnd()
13784 
    oprot.writeFieldStop()
13785 
    oprot.writeStructEnd()
13786 
 
3431 rajveer 13787 
  def validate(self):
13788 
    return
13789 
 
13790 
 
2690 chandransh 13791 
  def __repr__(self):
13792 
    L = ['%s=%r' % (key, value)
13793 
      for key, value in self.__dict__.iteritems()]
13794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13795 
 
13796 
  def __eq__(self, other):
13797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13798 
 
13799 
  def __ne__(self, other):
13800 
    return not (self == other)
13801 
 
2819 chandransh 13802 
class createPurchaseOrder_args:
13803 
  """
13804 
  Attributes:
13805 
   - warehouseId
13806 
  """
2690 chandransh 13807 
 
2819 chandransh 13808 
  thrift_spec = (
13809 
    None, # 0
13810 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13811 
  )
13812 
 
13813 
  def __init__(self, warehouseId=None,):
13814 
    self.warehouseId = warehouseId
13815 
 
13816 
  def read(self, iprot):
13817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13819 
      return
13820 
    iprot.readStructBegin()
13821 
    while True:
13822 
      (fname, ftype, fid) = iprot.readFieldBegin()
13823 
      if ftype == TType.STOP:
13824 
        break
13825 
      if fid == 1:
13826 
        if ftype == TType.I64:
13827 
          self.warehouseId = iprot.readI64();
13828 
        else:
13829 
          iprot.skip(ftype)
13830 
      else:
13831 
        iprot.skip(ftype)
13832 
      iprot.readFieldEnd()
13833 
    iprot.readStructEnd()
13834 
 
13835 
  def write(self, oprot):
13836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13838 
      return
13839 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13840 
    if self.warehouseId is not None:
2819 chandransh 13841 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13842 
      oprot.writeI64(self.warehouseId)
13843 
      oprot.writeFieldEnd()
13844 
    oprot.writeFieldStop()
13845 
    oprot.writeStructEnd()
13846 
 
3431 rajveer 13847 
  def validate(self):
13848 
    return
13849 
 
13850 
 
2819 chandransh 13851 
  def __repr__(self):
13852 
    L = ['%s=%r' % (key, value)
13853 
      for key, value in self.__dict__.iteritems()]
13854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13855 
 
13856 
  def __eq__(self, other):
13857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13858 
 
13859 
  def __ne__(self, other):
13860 
    return not (self == other)
13861 
 
13862 
class createPurchaseOrder_result:
13863 
  """
13864 
  Attributes:
13865 
   - success
13866 
   - ex
13867 
  """
13868 
 
13869 
  thrift_spec = (
4586 mandeep.dh 13870 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13872 
  )
13873 
 
13874 
  def __init__(self, success=None, ex=None,):
13875 
    self.success = success
13876 
    self.ex = ex
13877 
 
13878 
  def read(self, iprot):
13879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13881 
      return
13882 
    iprot.readStructBegin()
13883 
    while True:
13884 
      (fname, ftype, fid) = iprot.readFieldBegin()
13885 
      if ftype == TType.STOP:
13886 
        break
13887 
      if fid == 0:
4586 mandeep.dh 13888 
        if ftype == TType.LIST:
13889 
          self.success = []
13890 
          (_etype223, _size220) = iprot.readListBegin()
13891 
          for _i224 in xrange(_size220):
13892 
            _elem225 = iprot.readI64();
13893 
            self.success.append(_elem225)
13894 
          iprot.readListEnd()
2819 chandransh 13895 
        else:
13896 
          iprot.skip(ftype)
13897 
      elif fid == 1:
13898 
        if ftype == TType.STRUCT:
13899 
          self.ex = TransactionServiceException()
13900 
          self.ex.read(iprot)
13901 
        else:
13902 
          iprot.skip(ftype)
13903 
      else:
13904 
        iprot.skip(ftype)
13905 
      iprot.readFieldEnd()
13906 
    iprot.readStructEnd()
13907 
 
13908 
  def write(self, oprot):
13909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13911 
      return
13912 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13913 
    if self.success is not None:
4586 mandeep.dh 13914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13915 
      oprot.writeListBegin(TType.I64, len(self.success))
13916 
      for iter226 in self.success:
13917 
        oprot.writeI64(iter226)
13918 
      oprot.writeListEnd()
2819 chandransh 13919 
      oprot.writeFieldEnd()
3431 rajveer 13920 
    if self.ex is not None:
2819 chandransh 13921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13922 
      self.ex.write(oprot)
13923 
      oprot.writeFieldEnd()
13924 
    oprot.writeFieldStop()
13925 
    oprot.writeStructEnd()
13926 
 
3431 rajveer 13927 
  def validate(self):
13928 
    return
13929 
 
13930 
 
2819 chandransh 13931 
  def __repr__(self):
13932 
    L = ['%s=%r' % (key, value)
13933 
      for key, value in self.__dict__.iteritems()]
13934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13935 
 
13936 
  def __eq__(self, other):
13937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13938 
 
13939 
  def __ne__(self, other):
13940 
    return not (self == other)
3451 chandransh 13941 
 
13942 
class updateWeight_args:
13943 
  """
13944 
  Attributes:
13945 
   - orderId
13946 
   - weight
13947 
  """
13948 
 
13949 
  thrift_spec = (
13950 
    None, # 0
13951 
    (1, TType.I64, 'orderId', None, None, ), # 1
13952 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13953 
  )
13954 
 
13955 
  def __init__(self, orderId=None, weight=None,):
13956 
    self.orderId = orderId
13957 
    self.weight = weight
13958 
 
13959 
  def read(self, iprot):
13960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13962 
      return
13963 
    iprot.readStructBegin()
13964 
    while True:
13965 
      (fname, ftype, fid) = iprot.readFieldBegin()
13966 
      if ftype == TType.STOP:
13967 
        break
13968 
      if fid == 1:
13969 
        if ftype == TType.I64:
13970 
          self.orderId = iprot.readI64();
13971 
        else:
13972 
          iprot.skip(ftype)
13973 
      elif fid == 2:
13974 
        if ftype == TType.DOUBLE:
13975 
          self.weight = iprot.readDouble();
13976 
        else:
13977 
          iprot.skip(ftype)
13978 
      else:
13979 
        iprot.skip(ftype)
13980 
      iprot.readFieldEnd()
13981 
    iprot.readStructEnd()
13982 
 
13983 
  def write(self, oprot):
13984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13986 
      return
13987 
    oprot.writeStructBegin('updateWeight_args')
13988 
    if self.orderId is not None:
13989 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13990 
      oprot.writeI64(self.orderId)
13991 
      oprot.writeFieldEnd()
13992 
    if self.weight is not None:
13993 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13994 
      oprot.writeDouble(self.weight)
13995 
      oprot.writeFieldEnd()
13996 
    oprot.writeFieldStop()
13997 
    oprot.writeStructEnd()
13998 
 
13999 
  def validate(self):
14000 
    return
14001 
 
14002 
 
14003 
  def __repr__(self):
14004 
    L = ['%s=%r' % (key, value)
14005 
      for key, value in self.__dict__.iteritems()]
14006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14007 
 
14008 
  def __eq__(self, other):
14009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14010 
 
14011 
  def __ne__(self, other):
14012 
    return not (self == other)
14013 
 
14014 
class updateWeight_result:
14015 
  """
14016 
  Attributes:
14017 
   - success
14018 
   - ex
14019 
  """
14020 
 
14021 
  thrift_spec = (
14022 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14024 
  )
14025 
 
14026 
  def __init__(self, success=None, ex=None,):
14027 
    self.success = success
14028 
    self.ex = ex
14029 
 
14030 
  def read(self, iprot):
14031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14033 
      return
14034 
    iprot.readStructBegin()
14035 
    while True:
14036 
      (fname, ftype, fid) = iprot.readFieldBegin()
14037 
      if ftype == TType.STOP:
14038 
        break
14039 
      if fid == 0:
14040 
        if ftype == TType.STRUCT:
14041 
          self.success = Order()
14042 
          self.success.read(iprot)
14043 
        else:
14044 
          iprot.skip(ftype)
14045 
      elif fid == 1:
14046 
        if ftype == TType.STRUCT:
14047 
          self.ex = TransactionServiceException()
14048 
          self.ex.read(iprot)
14049 
        else:
14050 
          iprot.skip(ftype)
14051 
      else:
14052 
        iprot.skip(ftype)
14053 
      iprot.readFieldEnd()
14054 
    iprot.readStructEnd()
14055 
 
14056 
  def write(self, oprot):
14057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14059 
      return
14060 
    oprot.writeStructBegin('updateWeight_result')
14061 
    if self.success is not None:
14062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14063 
      self.success.write(oprot)
14064 
      oprot.writeFieldEnd()
14065 
    if self.ex is not None:
14066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14067 
      self.ex.write(oprot)
14068 
      oprot.writeFieldEnd()
14069 
    oprot.writeFieldStop()
14070 
    oprot.writeStructEnd()
14071 
 
14072 
  def validate(self):
14073 
    return
14074 
 
14075 
 
14076 
  def __repr__(self):
14077 
    L = ['%s=%r' % (key, value)
14078 
      for key, value in self.__dict__.iteritems()]
14079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14080 
 
14081 
  def __eq__(self, other):
14082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14083 
 
14084 
  def __ne__(self, other):
14085 
    return not (self == other)
3469 chandransh 14086 
 
14087 
class changeItem_args:
14088 
  """
14089 
  Attributes:
14090 
   - orderId
14091 
   - itemId
14092 
  """
14093 
 
14094 
  thrift_spec = (
14095 
    None, # 0
14096 
    (1, TType.I64, 'orderId', None, None, ), # 1
14097 
    (2, TType.I64, 'itemId', None, None, ), # 2
14098 
  )
14099 
 
14100 
  def __init__(self, orderId=None, itemId=None,):
14101 
    self.orderId = orderId
14102 
    self.itemId = itemId
14103 
 
14104 
  def read(self, iprot):
14105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14107 
      return
14108 
    iprot.readStructBegin()
14109 
    while True:
14110 
      (fname, ftype, fid) = iprot.readFieldBegin()
14111 
      if ftype == TType.STOP:
14112 
        break
14113 
      if fid == 1:
14114 
        if ftype == TType.I64:
14115 
          self.orderId = iprot.readI64();
14116 
        else:
14117 
          iprot.skip(ftype)
14118 
      elif fid == 2:
14119 
        if ftype == TType.I64:
14120 
          self.itemId = iprot.readI64();
14121 
        else:
14122 
          iprot.skip(ftype)
14123 
      else:
14124 
        iprot.skip(ftype)
14125 
      iprot.readFieldEnd()
14126 
    iprot.readStructEnd()
14127 
 
14128 
  def write(self, oprot):
14129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14131 
      return
14132 
    oprot.writeStructBegin('changeItem_args')
14133 
    if self.orderId is not None:
14134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14135 
      oprot.writeI64(self.orderId)
14136 
      oprot.writeFieldEnd()
14137 
    if self.itemId is not None:
14138 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14139 
      oprot.writeI64(self.itemId)
14140 
      oprot.writeFieldEnd()
14141 
    oprot.writeFieldStop()
14142 
    oprot.writeStructEnd()
14143 
 
14144 
  def validate(self):
14145 
    return
14146 
 
14147 
 
14148 
  def __repr__(self):
14149 
    L = ['%s=%r' % (key, value)
14150 
      for key, value in self.__dict__.iteritems()]
14151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14152 
 
14153 
  def __eq__(self, other):
14154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14155 
 
14156 
  def __ne__(self, other):
14157 
    return not (self == other)
14158 
 
14159 
class changeItem_result:
14160 
  """
14161 
  Attributes:
14162 
   - success
14163 
   - ex
14164 
  """
14165 
 
14166 
  thrift_spec = (
14167 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14169 
  )
14170 
 
14171 
  def __init__(self, success=None, ex=None,):
14172 
    self.success = success
14173 
    self.ex = ex
14174 
 
14175 
  def read(self, iprot):
14176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14178 
      return
14179 
    iprot.readStructBegin()
14180 
    while True:
14181 
      (fname, ftype, fid) = iprot.readFieldBegin()
14182 
      if ftype == TType.STOP:
14183 
        break
14184 
      if fid == 0:
14185 
        if ftype == TType.STRUCT:
14186 
          self.success = Order()
14187 
          self.success.read(iprot)
14188 
        else:
14189 
          iprot.skip(ftype)
14190 
      elif fid == 1:
14191 
        if ftype == TType.STRUCT:
14192 
          self.ex = TransactionServiceException()
14193 
          self.ex.read(iprot)
14194 
        else:
14195 
          iprot.skip(ftype)
14196 
      else:
14197 
        iprot.skip(ftype)
14198 
      iprot.readFieldEnd()
14199 
    iprot.readStructEnd()
14200 
 
14201 
  def write(self, oprot):
14202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14204 
      return
14205 
    oprot.writeStructBegin('changeItem_result')
14206 
    if self.success is not None:
14207 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14208 
      self.success.write(oprot)
14209 
      oprot.writeFieldEnd()
14210 
    if self.ex is not None:
14211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14212 
      self.ex.write(oprot)
14213 
      oprot.writeFieldEnd()
14214 
    oprot.writeFieldStop()
14215 
    oprot.writeStructEnd()
14216 
 
14217 
  def validate(self):
14218 
    return
14219 
 
14220 
 
14221 
  def __repr__(self):
14222 
    L = ['%s=%r' % (key, value)
14223 
      for key, value in self.__dict__.iteritems()]
14224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14225 
 
14226 
  def __eq__(self, other):
14227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14228 
 
14229 
  def __ne__(self, other):
14230 
    return not (self == other)
14231 
 
14232 
class shiftToWarehouse_args:
14233 
  """
14234 
  Attributes:
14235 
   - orderId
14236 
   - warehouseId
14237 
  """
14238 
 
14239 
  thrift_spec = (
14240 
    None, # 0
14241 
    (1, TType.I64, 'orderId', None, None, ), # 1
14242 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14243 
  )
14244 
 
14245 
  def __init__(self, orderId=None, warehouseId=None,):
14246 
    self.orderId = orderId
14247 
    self.warehouseId = warehouseId
14248 
 
14249 
  def read(self, iprot):
14250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14252 
      return
14253 
    iprot.readStructBegin()
14254 
    while True:
14255 
      (fname, ftype, fid) = iprot.readFieldBegin()
14256 
      if ftype == TType.STOP:
14257 
        break
14258 
      if fid == 1:
14259 
        if ftype == TType.I64:
14260 
          self.orderId = iprot.readI64();
14261 
        else:
14262 
          iprot.skip(ftype)
14263 
      elif fid == 2:
14264 
        if ftype == TType.I64:
14265 
          self.warehouseId = iprot.readI64();
14266 
        else:
14267 
          iprot.skip(ftype)
14268 
      else:
14269 
        iprot.skip(ftype)
14270 
      iprot.readFieldEnd()
14271 
    iprot.readStructEnd()
14272 
 
14273 
  def write(self, oprot):
14274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14276 
      return
14277 
    oprot.writeStructBegin('shiftToWarehouse_args')
14278 
    if self.orderId is not None:
14279 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14280 
      oprot.writeI64(self.orderId)
14281 
      oprot.writeFieldEnd()
14282 
    if self.warehouseId is not None:
14283 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14284 
      oprot.writeI64(self.warehouseId)
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
14303 
 
14304 
class shiftToWarehouse_result:
14305 
  """
14306 
  Attributes:
14307 
   - success
14308 
   - ex
14309 
  """
14310 
 
14311 
  thrift_spec = (
14312 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14313 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14314 
  )
14315 
 
14316 
  def __init__(self, success=None, ex=None,):
14317 
    self.success = success
14318 
    self.ex = ex
14319 
 
14320 
  def read(self, iprot):
14321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14323 
      return
14324 
    iprot.readStructBegin()
14325 
    while True:
14326 
      (fname, ftype, fid) = iprot.readFieldBegin()
14327 
      if ftype == TType.STOP:
14328 
        break
14329 
      if fid == 0:
14330 
        if ftype == TType.STRUCT:
14331 
          self.success = Order()
14332 
          self.success.read(iprot)
14333 
        else:
14334 
          iprot.skip(ftype)
14335 
      elif fid == 1:
14336 
        if ftype == TType.STRUCT:
14337 
          self.ex = TransactionServiceException()
14338 
          self.ex.read(iprot)
14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      else:
14342 
        iprot.skip(ftype)
14343 
      iprot.readFieldEnd()
14344 
    iprot.readStructEnd()
14345 
 
14346 
  def write(self, oprot):
14347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14349 
      return
14350 
    oprot.writeStructBegin('shiftToWarehouse_result')
14351 
    if self.success is not None:
14352 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14353 
      self.success.write(oprot)
14354 
      oprot.writeFieldEnd()
14355 
    if self.ex is not None:
14356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14357 
      self.ex.write(oprot)
14358 
      oprot.writeFieldEnd()
14359 
    oprot.writeFieldStop()
14360 
    oprot.writeStructEnd()
14361 
 
14362 
  def validate(self):
14363 
    return
14364 
 
14365 
 
14366 
  def __repr__(self):
14367 
    L = ['%s=%r' % (key, value)
14368 
      for key, value in self.__dict__.iteritems()]
14369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14370 
 
14371 
  def __eq__(self, other):
14372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14373 
 
14374 
  def __ne__(self, other):
14375 
    return not (self == other)
3553 chandransh 14376 
 
14377 
class addDelayReason_args:
14378 
  """
14379 
  Attributes:
14380 
   - orderId
14381 
   - delayReason
3986 chandransh 14382 
   - furtherDelay
4647 rajveer 14383 
   - delayReasonText
3553 chandransh 14384 
  """
14385 
 
14386 
  thrift_spec = (
14387 
    None, # 0
14388 
    (1, TType.I64, 'orderId', None, None, ), # 1
14389 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14390 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14391 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14392 
  )
14393 
 
4647 rajveer 14394 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14395 
    self.orderId = orderId
14396 
    self.delayReason = delayReason
3986 chandransh 14397 
    self.furtherDelay = furtherDelay
4647 rajveer 14398 
    self.delayReasonText = delayReasonText
3553 chandransh 14399 
 
14400 
  def read(self, iprot):
14401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14403 
      return
14404 
    iprot.readStructBegin()
14405 
    while True:
14406 
      (fname, ftype, fid) = iprot.readFieldBegin()
14407 
      if ftype == TType.STOP:
14408 
        break
14409 
      if fid == 1:
14410 
        if ftype == TType.I64:
14411 
          self.orderId = iprot.readI64();
14412 
        else:
14413 
          iprot.skip(ftype)
14414 
      elif fid == 2:
14415 
        if ftype == TType.I32:
14416 
          self.delayReason = iprot.readI32();
14417 
        else:
14418 
          iprot.skip(ftype)
3986 chandransh 14419 
      elif fid == 3:
14420 
        if ftype == TType.I64:
14421 
          self.furtherDelay = iprot.readI64();
14422 
        else:
14423 
          iprot.skip(ftype)
4647 rajveer 14424 
      elif fid == 4:
14425 
        if ftype == TType.STRING:
14426 
          self.delayReasonText = iprot.readString();
14427 
        else:
14428 
          iprot.skip(ftype)
3553 chandransh 14429 
      else:
14430 
        iprot.skip(ftype)
14431 
      iprot.readFieldEnd()
14432 
    iprot.readStructEnd()
14433 
 
14434 
  def write(self, oprot):
14435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14437 
      return
14438 
    oprot.writeStructBegin('addDelayReason_args')
14439 
    if self.orderId is not None:
14440 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14441 
      oprot.writeI64(self.orderId)
14442 
      oprot.writeFieldEnd()
14443 
    if self.delayReason is not None:
14444 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14445 
      oprot.writeI32(self.delayReason)
14446 
      oprot.writeFieldEnd()
3986 chandransh 14447 
    if self.furtherDelay is not None:
14448 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14449 
      oprot.writeI64(self.furtherDelay)
14450 
      oprot.writeFieldEnd()
4647 rajveer 14451 
    if self.delayReasonText is not None:
14452 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14453 
      oprot.writeString(self.delayReasonText)
14454 
      oprot.writeFieldEnd()
3553 chandransh 14455 
    oprot.writeFieldStop()
14456 
    oprot.writeStructEnd()
14457 
 
14458 
  def validate(self):
14459 
    return
14460 
 
14461 
 
14462 
  def __repr__(self):
14463 
    L = ['%s=%r' % (key, value)
14464 
      for key, value in self.__dict__.iteritems()]
14465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14466 
 
14467 
  def __eq__(self, other):
14468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14469 
 
14470 
  def __ne__(self, other):
14471 
    return not (self == other)
14472 
 
14473 
class addDelayReason_result:
14474 
  """
14475 
  Attributes:
14476 
   - success
14477 
   - ex
14478 
  """
14479 
 
14480 
  thrift_spec = (
14481 
    (0, TType.BOOL, 'success', None, None, ), # 0
14482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14483 
  )
14484 
 
14485 
  def __init__(self, success=None, ex=None,):
14486 
    self.success = success
14487 
    self.ex = ex
14488 
 
14489 
  def read(self, iprot):
14490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14492 
      return
14493 
    iprot.readStructBegin()
14494 
    while True:
14495 
      (fname, ftype, fid) = iprot.readFieldBegin()
14496 
      if ftype == TType.STOP:
14497 
        break
14498 
      if fid == 0:
14499 
        if ftype == TType.BOOL:
14500 
          self.success = iprot.readBool();
14501 
        else:
14502 
          iprot.skip(ftype)
14503 
      elif fid == 1:
14504 
        if ftype == TType.STRUCT:
14505 
          self.ex = TransactionServiceException()
14506 
          self.ex.read(iprot)
14507 
        else:
14508 
          iprot.skip(ftype)
14509 
      else:
14510 
        iprot.skip(ftype)
14511 
      iprot.readFieldEnd()
14512 
    iprot.readStructEnd()
14513 
 
14514 
  def write(self, oprot):
14515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14517 
      return
14518 
    oprot.writeStructBegin('addDelayReason_result')
14519 
    if self.success is not None:
14520 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14521 
      oprot.writeBool(self.success)
14522 
      oprot.writeFieldEnd()
14523 
    if self.ex is not None:
14524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14525 
      self.ex.write(oprot)
14526 
      oprot.writeFieldEnd()
14527 
    oprot.writeFieldStop()
14528 
    oprot.writeStructEnd()
14529 
 
14530 
  def validate(self):
14531 
    return
14532 
 
14533 
 
14534 
  def __repr__(self):
14535 
    L = ['%s=%r' % (key, value)
14536 
      for key, value in self.__dict__.iteritems()]
14537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14538 
 
14539 
  def __eq__(self, other):
14540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14541 
 
14542 
  def __ne__(self, other):
14543 
    return not (self == other)
3956 chandransh 14544 
 
14545 
class reconcileCodCollection_args:
14546 
  """
14547 
  Attributes:
14548 
   - collectedAmountMap
14549 
   - xferBy
14550 
   - xferTxnId
14551 
   - xferDate
14552 
  """
14553 
 
14554 
  thrift_spec = (
14555 
    None, # 0
14556 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14557 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14558 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14559 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14560 
  )
14561 
 
14562 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14563 
    self.collectedAmountMap = collectedAmountMap
14564 
    self.xferBy = xferBy
14565 
    self.xferTxnId = xferTxnId
14566 
    self.xferDate = xferDate
14567 
 
14568 
  def read(self, iprot):
14569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14571 
      return
14572 
    iprot.readStructBegin()
14573 
    while True:
14574 
      (fname, ftype, fid) = iprot.readFieldBegin()
14575 
      if ftype == TType.STOP:
14576 
        break
14577 
      if fid == 1:
14578 
        if ftype == TType.MAP:
14579 
          self.collectedAmountMap = {}
4586 mandeep.dh 14580 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14581 
          for _i231 in xrange(_size227):
14582 
            _key232 = iprot.readString();
14583 
            _val233 = iprot.readDouble();
14584 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14585 
          iprot.readMapEnd()
14586 
        else:
14587 
          iprot.skip(ftype)
14588 
      elif fid == 2:
14589 
        if ftype == TType.STRING:
14590 
          self.xferBy = iprot.readString();
14591 
        else:
14592 
          iprot.skip(ftype)
14593 
      elif fid == 3:
14594 
        if ftype == TType.STRING:
14595 
          self.xferTxnId = iprot.readString();
14596 
        else:
14597 
          iprot.skip(ftype)
14598 
      elif fid == 4:
14599 
        if ftype == TType.I64:
14600 
          self.xferDate = iprot.readI64();
14601 
        else:
14602 
          iprot.skip(ftype)
14603 
      else:
14604 
        iprot.skip(ftype)
14605 
      iprot.readFieldEnd()
14606 
    iprot.readStructEnd()
14607 
 
14608 
  def write(self, oprot):
14609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14611 
      return
14612 
    oprot.writeStructBegin('reconcileCodCollection_args')
14613 
    if self.collectedAmountMap is not None:
14614 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14615 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14616 
      for kiter234,viter235 in self.collectedAmountMap.items():
14617 
        oprot.writeString(kiter234)
14618 
        oprot.writeDouble(viter235)
3956 chandransh 14619 
      oprot.writeMapEnd()
14620 
      oprot.writeFieldEnd()
14621 
    if self.xferBy is not None:
14622 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14623 
      oprot.writeString(self.xferBy)
14624 
      oprot.writeFieldEnd()
14625 
    if self.xferTxnId is not None:
14626 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14627 
      oprot.writeString(self.xferTxnId)
14628 
      oprot.writeFieldEnd()
14629 
    if self.xferDate is not None:
14630 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14631 
      oprot.writeI64(self.xferDate)
14632 
      oprot.writeFieldEnd()
14633 
    oprot.writeFieldStop()
14634 
    oprot.writeStructEnd()
14635 
 
14636 
  def validate(self):
14637 
    return
14638 
 
14639 
 
14640 
  def __repr__(self):
14641 
    L = ['%s=%r' % (key, value)
14642 
      for key, value in self.__dict__.iteritems()]
14643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14644 
 
14645 
  def __eq__(self, other):
14646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14647 
 
14648 
  def __ne__(self, other):
14649 
    return not (self == other)
14650 
 
14651 
class reconcileCodCollection_result:
14652 
  """
14653 
  Attributes:
14654 
   - success
14655 
   - ex
14656 
  """
14657 
 
14658 
  thrift_spec = (
14659 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14661 
  )
14662 
 
14663 
  def __init__(self, success=None, ex=None,):
14664 
    self.success = success
14665 
    self.ex = ex
14666 
 
14667 
  def read(self, iprot):
14668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14670 
      return
14671 
    iprot.readStructBegin()
14672 
    while True:
14673 
      (fname, ftype, fid) = iprot.readFieldBegin()
14674 
      if ftype == TType.STOP:
14675 
        break
14676 
      if fid == 0:
14677 
        if ftype == TType.MAP:
14678 
          self.success = {}
4586 mandeep.dh 14679 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14680 
          for _i240 in xrange(_size236):
14681 
            _key241 = iprot.readString();
14682 
            _val242 = iprot.readString();
14683 
            self.success[_key241] = _val242
3956 chandransh 14684 
          iprot.readMapEnd()
14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      elif fid == 1:
14688 
        if ftype == TType.STRUCT:
14689 
          self.ex = TransactionServiceException()
14690 
          self.ex.read(iprot)
14691 
        else:
14692 
          iprot.skip(ftype)
14693 
      else:
14694 
        iprot.skip(ftype)
14695 
      iprot.readFieldEnd()
14696 
    iprot.readStructEnd()
14697 
 
14698 
  def write(self, oprot):
14699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14701 
      return
14702 
    oprot.writeStructBegin('reconcileCodCollection_result')
14703 
    if self.success is not None:
14704 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14705 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14706 
      for kiter243,viter244 in self.success.items():
14707 
        oprot.writeString(kiter243)
14708 
        oprot.writeString(viter244)
3956 chandransh 14709 
      oprot.writeMapEnd()
14710 
      oprot.writeFieldEnd()
14711 
    if self.ex is not None:
14712 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14713 
      self.ex.write(oprot)
14714 
      oprot.writeFieldEnd()
14715 
    oprot.writeFieldStop()
14716 
    oprot.writeStructEnd()
14717 
 
14718 
  def validate(self):
14719 
    return
14720 
 
14721 
 
14722 
  def __repr__(self):
14723 
    L = ['%s=%r' % (key, value)
14724 
      for key, value in self.__dict__.iteritems()]
14725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14726 
 
14727 
  def __eq__(self, other):
14728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14729 
 
14730 
  def __ne__(self, other):
14731 
    return not (self == other)
4008 mandeep.dh 14732 
 
14733 
class getTransactionsRequiringExtraProcessing_args:
14734 
  """
14735 
  Attributes:
14736 
   - category
14737 
  """
14738 
 
14739 
  thrift_spec = (
14740 
    None, # 0
14741 
    (1, TType.I32, 'category', None, None, ), # 1
14742 
  )
14743 
 
14744 
  def __init__(self, category=None,):
14745 
    self.category = category
14746 
 
14747 
  def read(self, iprot):
14748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14750 
      return
14751 
    iprot.readStructBegin()
14752 
    while True:
14753 
      (fname, ftype, fid) = iprot.readFieldBegin()
14754 
      if ftype == TType.STOP:
14755 
        break
14756 
      if fid == 1:
14757 
        if ftype == TType.I32:
14758 
          self.category = iprot.readI32();
14759 
        else:
14760 
          iprot.skip(ftype)
14761 
      else:
14762 
        iprot.skip(ftype)
14763 
      iprot.readFieldEnd()
14764 
    iprot.readStructEnd()
14765 
 
14766 
  def write(self, oprot):
14767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14769 
      return
14770 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14771 
    if self.category is not None:
14772 
      oprot.writeFieldBegin('category', TType.I32, 1)
14773 
      oprot.writeI32(self.category)
14774 
      oprot.writeFieldEnd()
14775 
    oprot.writeFieldStop()
14776 
    oprot.writeStructEnd()
14777 
 
14778 
  def validate(self):
14779 
    return
14780 
 
14781 
 
14782 
  def __repr__(self):
14783 
    L = ['%s=%r' % (key, value)
14784 
      for key, value in self.__dict__.iteritems()]
14785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14786 
 
14787 
  def __eq__(self, other):
14788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14789 
 
14790 
  def __ne__(self, other):
14791 
    return not (self == other)
14792 
 
14793 
class getTransactionsRequiringExtraProcessing_result:
14794 
  """
14795 
  Attributes:
14796 
   - success
14797 
  """
14798 
 
14799 
  thrift_spec = (
14800 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14801 
  )
14802 
 
14803 
  def __init__(self, success=None,):
14804 
    self.success = success
14805 
 
14806 
  def read(self, iprot):
14807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14809 
      return
14810 
    iprot.readStructBegin()
14811 
    while True:
14812 
      (fname, ftype, fid) = iprot.readFieldBegin()
14813 
      if ftype == TType.STOP:
14814 
        break
14815 
      if fid == 0:
14816 
        if ftype == TType.LIST:
14817 
          self.success = []
4586 mandeep.dh 14818 
          (_etype248, _size245) = iprot.readListBegin()
14819 
          for _i249 in xrange(_size245):
14820 
            _elem250 = iprot.readI64();
14821 
            self.success.append(_elem250)
4008 mandeep.dh 14822 
          iprot.readListEnd()
14823 
        else:
14824 
          iprot.skip(ftype)
14825 
      else:
14826 
        iprot.skip(ftype)
14827 
      iprot.readFieldEnd()
14828 
    iprot.readStructEnd()
14829 
 
14830 
  def write(self, oprot):
14831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14833 
      return
14834 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14835 
    if self.success is not None:
14836 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14837 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14838 
      for iter251 in self.success:
14839 
        oprot.writeI64(iter251)
4008 mandeep.dh 14840 
      oprot.writeListEnd()
14841 
      oprot.writeFieldEnd()
14842 
    oprot.writeFieldStop()
14843 
    oprot.writeStructEnd()
14844 
 
14845 
  def validate(self):
14846 
    return
14847 
 
14848 
 
14849 
  def __repr__(self):
14850 
    L = ['%s=%r' % (key, value)
14851 
      for key, value in self.__dict__.iteritems()]
14852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14853 
 
14854 
  def __eq__(self, other):
14855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14856 
 
14857 
  def __ne__(self, other):
14858 
    return not (self == other)
14859 
 
14860 
class markTransactionAsProcessed_args:
14861 
  """
14862 
  Attributes:
14863 
   - transactionId
14864 
   - category
14865 
  """
14866 
 
14867 
  thrift_spec = (
14868 
    None, # 0
14869 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14870 
    (2, TType.I32, 'category', None, None, ), # 2
14871 
  )
14872 
 
14873 
  def __init__(self, transactionId=None, category=None,):
14874 
    self.transactionId = transactionId
14875 
    self.category = category
14876 
 
14877 
  def read(self, iprot):
14878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14880 
      return
14881 
    iprot.readStructBegin()
14882 
    while True:
14883 
      (fname, ftype, fid) = iprot.readFieldBegin()
14884 
      if ftype == TType.STOP:
14885 
        break
14886 
      if fid == 1:
14887 
        if ftype == TType.I64:
14888 
          self.transactionId = iprot.readI64();
14889 
        else:
14890 
          iprot.skip(ftype)
14891 
      elif fid == 2:
14892 
        if ftype == TType.I32:
14893 
          self.category = iprot.readI32();
14894 
        else:
14895 
          iprot.skip(ftype)
14896 
      else:
14897 
        iprot.skip(ftype)
14898 
      iprot.readFieldEnd()
14899 
    iprot.readStructEnd()
14900 
 
14901 
  def write(self, oprot):
14902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14904 
      return
14905 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14906 
    if self.transactionId is not None:
14907 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14908 
      oprot.writeI64(self.transactionId)
14909 
      oprot.writeFieldEnd()
14910 
    if self.category is not None:
14911 
      oprot.writeFieldBegin('category', TType.I32, 2)
14912 
      oprot.writeI32(self.category)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
14931 
 
14932 
class markTransactionAsProcessed_result:
14933 
 
14934 
  thrift_spec = (
14935 
  )
14936 
 
14937 
  def read(self, iprot):
14938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14940 
      return
14941 
    iprot.readStructBegin()
14942 
    while True:
14943 
      (fname, ftype, fid) = iprot.readFieldBegin()
14944 
      if ftype == TType.STOP:
14945 
        break
14946 
      else:
14947 
        iprot.skip(ftype)
14948 
      iprot.readFieldEnd()
14949 
    iprot.readStructEnd()
14950 
 
14951 
  def write(self, oprot):
14952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14954 
      return
14955 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14956 
    oprot.writeFieldStop()
14957 
    oprot.writeStructEnd()
14958 
 
14959 
  def validate(self):
14960 
    return
14961 
 
14962 
 
14963 
  def __repr__(self):
14964 
    L = ['%s=%r' % (key, value)
14965 
      for key, value in self.__dict__.iteritems()]
14966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14967 
 
14968 
  def __eq__(self, other):
14969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14970 
 
14971 
  def __ne__(self, other):
14972 
    return not (self == other)
4018 chandransh 14973 
 
14974 
class getItemWiseRiskyOrdersCount_args:
14975 
 
14976 
  thrift_spec = (
14977 
  )
14978 
 
14979 
  def read(self, iprot):
14980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14982 
      return
14983 
    iprot.readStructBegin()
14984 
    while True:
14985 
      (fname, ftype, fid) = iprot.readFieldBegin()
14986 
      if ftype == TType.STOP:
14987 
        break
14988 
      else:
14989 
        iprot.skip(ftype)
14990 
      iprot.readFieldEnd()
14991 
    iprot.readStructEnd()
14992 
 
14993 
  def write(self, oprot):
14994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14996 
      return
14997 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14998 
    oprot.writeFieldStop()
14999 
    oprot.writeStructEnd()
15000 
 
15001 
  def validate(self):
15002 
    return
15003 
 
15004 
 
15005 
  def __repr__(self):
15006 
    L = ['%s=%r' % (key, value)
15007 
      for key, value in self.__dict__.iteritems()]
15008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15009 
 
15010 
  def __eq__(self, other):
15011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15012 
 
15013 
  def __ne__(self, other):
15014 
    return not (self == other)
15015 
 
15016 
class getItemWiseRiskyOrdersCount_result:
15017 
  """
15018 
  Attributes:
15019 
   - success
15020 
  """
15021 
 
15022 
  thrift_spec = (
15023 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15024 
  )
15025 
 
15026 
  def __init__(self, success=None,):
15027 
    self.success = success
15028 
 
15029 
  def read(self, iprot):
15030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15032 
      return
15033 
    iprot.readStructBegin()
15034 
    while True:
15035 
      (fname, ftype, fid) = iprot.readFieldBegin()
15036 
      if ftype == TType.STOP:
15037 
        break
15038 
      if fid == 0:
15039 
        if ftype == TType.MAP:
15040 
          self.success = {}
4586 mandeep.dh 15041 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15042 
          for _i256 in xrange(_size252):
15043 
            _key257 = iprot.readI64();
15044 
            _val258 = iprot.readI64();
15045 
            self.success[_key257] = _val258
4018 chandransh 15046 
          iprot.readMapEnd()
15047 
        else:
15048 
          iprot.skip(ftype)
15049 
      else:
15050 
        iprot.skip(ftype)
15051 
      iprot.readFieldEnd()
15052 
    iprot.readStructEnd()
15053 
 
15054 
  def write(self, oprot):
15055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15057 
      return
15058 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15059 
    if self.success is not None:
15060 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15061 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 15062 
      for kiter259,viter260 in self.success.items():
15063 
        oprot.writeI64(kiter259)
15064 
        oprot.writeI64(viter260)
4018 chandransh 15065 
      oprot.writeMapEnd()
15066 
      oprot.writeFieldEnd()
15067 
    oprot.writeFieldStop()
15068 
    oprot.writeStructEnd()
15069 
 
15070 
  def validate(self):
15071 
    return
15072 
 
15073 
 
15074 
  def __repr__(self):
15075 
    L = ['%s=%r' % (key, value)
15076 
      for key, value in self.__dict__.iteritems()]
15077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15078 
 
15079 
  def __eq__(self, other):
15080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15081 
 
15082 
  def __ne__(self, other):
15083 
    return not (self == other)
4247 rajveer 15084 
 
4295 varun.gupt 15085 
class getOrdersForItemIds_args:
15086 
  """
15087 
  Attributes:
15088 
   - itemIds
15089 
  """
15090 
 
15091 
  thrift_spec = (
15092 
    None, # 0
15093 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15094 
  )
15095 
 
15096 
  def __init__(self, itemIds=None,):
15097 
    self.itemIds = itemIds
15098 
 
15099 
  def read(self, iprot):
15100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15102 
      return
15103 
    iprot.readStructBegin()
15104 
    while True:
15105 
      (fname, ftype, fid) = iprot.readFieldBegin()
15106 
      if ftype == TType.STOP:
15107 
        break
15108 
      if fid == 1:
15109 
        if ftype == TType.LIST:
15110 
          self.itemIds = []
4586 mandeep.dh 15111 
          (_etype264, _size261) = iprot.readListBegin()
15112 
          for _i265 in xrange(_size261):
15113 
            _elem266 = iprot.readI64();
15114 
            self.itemIds.append(_elem266)
4295 varun.gupt 15115 
          iprot.readListEnd()
15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      else:
15119 
        iprot.skip(ftype)
15120 
      iprot.readFieldEnd()
15121 
    iprot.readStructEnd()
15122 
 
15123 
  def write(self, oprot):
15124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15126 
      return
15127 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15128 
    if self.itemIds is not None:
15129 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15130 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15131 
      for iter267 in self.itemIds:
15132 
        oprot.writeI64(iter267)
4295 varun.gupt 15133 
      oprot.writeListEnd()
15134 
      oprot.writeFieldEnd()
15135 
    oprot.writeFieldStop()
15136 
    oprot.writeStructEnd()
15137 
 
15138 
  def validate(self):
15139 
    return
15140 
 
15141 
 
15142 
  def __repr__(self):
15143 
    L = ['%s=%r' % (key, value)
15144 
      for key, value in self.__dict__.iteritems()]
15145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15146 
 
15147 
  def __eq__(self, other):
15148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15149 
 
15150 
  def __ne__(self, other):
15151 
    return not (self == other)
15152 
 
15153 
class getOrdersForItemIds_result:
15154 
  """
15155 
  Attributes:
15156 
   - success
15157 
  """
15158 
 
15159 
  thrift_spec = (
15160 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15161 
  )
15162 
 
15163 
  def __init__(self, success=None,):
15164 
    self.success = success
15165 
 
15166 
  def read(self, iprot):
15167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15169 
      return
15170 
    iprot.readStructBegin()
15171 
    while True:
15172 
      (fname, ftype, fid) = iprot.readFieldBegin()
15173 
      if ftype == TType.STOP:
15174 
        break
15175 
      if fid == 0:
15176 
        if ftype == TType.LIST:
15177 
          self.success = []
4586 mandeep.dh 15178 
          (_etype271, _size268) = iprot.readListBegin()
15179 
          for _i272 in xrange(_size268):
15180 
            _elem273 = Order()
15181 
            _elem273.read(iprot)
15182 
            self.success.append(_elem273)
4295 varun.gupt 15183 
          iprot.readListEnd()
15184 
        else:
15185 
          iprot.skip(ftype)
15186 
      else:
15187 
        iprot.skip(ftype)
15188 
      iprot.readFieldEnd()
15189 
    iprot.readStructEnd()
15190 
 
15191 
  def write(self, oprot):
15192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15194 
      return
15195 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15196 
    if self.success is not None:
15197 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15198 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15199 
      for iter274 in self.success:
15200 
        iter274.write(oprot)
4295 varun.gupt 15201 
      oprot.writeListEnd()
15202 
      oprot.writeFieldEnd()
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
4247 rajveer 15221 
class markOrderCancellationRequestReceived_args:
15222 
  """
15223 
  Attributes:
15224 
   - orderId
15225 
  """
15226 
 
15227 
  thrift_spec = (
15228 
    None, # 0
15229 
    (1, TType.I64, 'orderId', None, None, ), # 1
15230 
  )
15231 
 
15232 
  def __init__(self, orderId=None,):
15233 
    self.orderId = orderId
15234 
 
15235 
  def read(self, iprot):
15236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15238 
      return
15239 
    iprot.readStructBegin()
15240 
    while True:
15241 
      (fname, ftype, fid) = iprot.readFieldBegin()
15242 
      if ftype == TType.STOP:
15243 
        break
15244 
      if fid == 1:
15245 
        if ftype == TType.I64:
15246 
          self.orderId = iprot.readI64();
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15259 
    if self.orderId is not None:
15260 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15261 
      oprot.writeI64(self.orderId)
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class markOrderCancellationRequestReceived_result:
15282 
  """
15283 
  Attributes:
15284 
   - ex
15285 
  """
15286 
 
15287 
  thrift_spec = (
15288 
    None, # 0
15289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15290 
  )
15291 
 
15292 
  def __init__(self, ex=None,):
15293 
    self.ex = ex
15294 
 
15295 
  def read(self, iprot):
15296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15298 
      return
15299 
    iprot.readStructBegin()
15300 
    while True:
15301 
      (fname, ftype, fid) = iprot.readFieldBegin()
15302 
      if ftype == TType.STOP:
15303 
        break
15304 
      if fid == 1:
15305 
        if ftype == TType.STRUCT:
15306 
          self.ex = TransactionServiceException()
15307 
          self.ex.read(iprot)
15308 
        else:
15309 
          iprot.skip(ftype)
15310 
      else:
15311 
        iprot.skip(ftype)
15312 
      iprot.readFieldEnd()
15313 
    iprot.readStructEnd()
15314 
 
15315 
  def write(self, oprot):
15316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15318 
      return
15319 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15320 
    if self.ex is not None:
15321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15322 
      self.ex.write(oprot)
15323 
      oprot.writeFieldEnd()
15324 
    oprot.writeFieldStop()
15325 
    oprot.writeStructEnd()
15326 
 
15327 
  def validate(self):
15328 
    return
15329 
 
15330 
 
15331 
  def __repr__(self):
15332 
    L = ['%s=%r' % (key, value)
15333 
      for key, value in self.__dict__.iteritems()]
15334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15335 
 
15336 
  def __eq__(self, other):
15337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15338 
 
15339 
  def __ne__(self, other):
15340 
    return not (self == other)
15341 
 
15342 
class markOrderCancellationRequestConfirmed_args:
15343 
  """
15344 
  Attributes:
15345 
   - orderId
15346 
  """
15347 
 
15348 
  thrift_spec = (
15349 
    None, # 0
15350 
    (1, TType.I64, 'orderId', None, None, ), # 1
15351 
  )
15352 
 
15353 
  def __init__(self, orderId=None,):
15354 
    self.orderId = orderId
15355 
 
15356 
  def read(self, iprot):
15357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15359 
      return
15360 
    iprot.readStructBegin()
15361 
    while True:
15362 
      (fname, ftype, fid) = iprot.readFieldBegin()
15363 
      if ftype == TType.STOP:
15364 
        break
15365 
      if fid == 1:
15366 
        if ftype == TType.I64:
15367 
          self.orderId = iprot.readI64();
15368 
        else:
15369 
          iprot.skip(ftype)
15370 
      else:
15371 
        iprot.skip(ftype)
15372 
      iprot.readFieldEnd()
15373 
    iprot.readStructEnd()
15374 
 
15375 
  def write(self, oprot):
15376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15378 
      return
15379 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15380 
    if self.orderId is not None:
15381 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15382 
      oprot.writeI64(self.orderId)
15383 
      oprot.writeFieldEnd()
15384 
    oprot.writeFieldStop()
15385 
    oprot.writeStructEnd()
15386 
 
15387 
  def validate(self):
15388 
    return
15389 
 
15390 
 
15391 
  def __repr__(self):
15392 
    L = ['%s=%r' % (key, value)
15393 
      for key, value in self.__dict__.iteritems()]
15394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15395 
 
15396 
  def __eq__(self, other):
15397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15398 
 
15399 
  def __ne__(self, other):
15400 
    return not (self == other)
15401 
 
15402 
class markOrderCancellationRequestConfirmed_result:
15403 
  """
15404 
  Attributes:
15405 
   - ex
15406 
  """
15407 
 
15408 
  thrift_spec = (
15409 
    None, # 0
15410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15411 
  )
15412 
 
15413 
  def __init__(self, ex=None,):
15414 
    self.ex = ex
15415 
 
15416 
  def read(self, iprot):
15417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15419 
      return
15420 
    iprot.readStructBegin()
15421 
    while True:
15422 
      (fname, ftype, fid) = iprot.readFieldBegin()
15423 
      if ftype == TType.STOP:
15424 
        break
15425 
      if fid == 1:
15426 
        if ftype == TType.STRUCT:
15427 
          self.ex = TransactionServiceException()
15428 
          self.ex.read(iprot)
15429 
        else:
15430 
          iprot.skip(ftype)
15431 
      else:
15432 
        iprot.skip(ftype)
15433 
      iprot.readFieldEnd()
15434 
    iprot.readStructEnd()
15435 
 
15436 
  def write(self, oprot):
15437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15439 
      return
15440 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15441 
    if self.ex is not None:
15442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15443 
      self.ex.write(oprot)
15444 
      oprot.writeFieldEnd()
15445 
    oprot.writeFieldStop()
15446 
    oprot.writeStructEnd()
15447 
 
15448 
  def validate(self):
15449 
    return
15450 
 
15451 
 
15452 
  def __repr__(self):
15453 
    L = ['%s=%r' % (key, value)
15454 
      for key, value in self.__dict__.iteritems()]
15455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15456 
 
15457 
  def __eq__(self, other):
15458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15459 
 
15460 
  def __ne__(self, other):
15461 
    return not (self == other)
15462 
 
15463 
class markOrderCancellationRequestDenied_args:
15464 
  """
15465 
  Attributes:
15466 
   - orderId
15467 
  """
15468 
 
15469 
  thrift_spec = (
15470 
    None, # 0
15471 
    (1, TType.I64, 'orderId', None, None, ), # 1
15472 
  )
15473 
 
15474 
  def __init__(self, orderId=None,):
15475 
    self.orderId = orderId
15476 
 
15477 
  def read(self, iprot):
15478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15480 
      return
15481 
    iprot.readStructBegin()
15482 
    while True:
15483 
      (fname, ftype, fid) = iprot.readFieldBegin()
15484 
      if ftype == TType.STOP:
15485 
        break
15486 
      if fid == 1:
15487 
        if ftype == TType.I64:
15488 
          self.orderId = iprot.readI64();
15489 
        else:
15490 
          iprot.skip(ftype)
15491 
      else:
15492 
        iprot.skip(ftype)
15493 
      iprot.readFieldEnd()
15494 
    iprot.readStructEnd()
15495 
 
15496 
  def write(self, oprot):
15497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15499 
      return
15500 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15501 
    if self.orderId is not None:
15502 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15503 
      oprot.writeI64(self.orderId)
15504 
      oprot.writeFieldEnd()
15505 
    oprot.writeFieldStop()
15506 
    oprot.writeStructEnd()
15507 
 
15508 
  def validate(self):
15509 
    return
15510 
 
15511 
 
15512 
  def __repr__(self):
15513 
    L = ['%s=%r' % (key, value)
15514 
      for key, value in self.__dict__.iteritems()]
15515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15516 
 
15517 
  def __eq__(self, other):
15518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15519 
 
15520 
  def __ne__(self, other):
15521 
    return not (self == other)
15522 
 
15523 
class markOrderCancellationRequestDenied_result:
15524 
  """
15525 
  Attributes:
15526 
   - ex
15527 
  """
15528 
 
15529 
  thrift_spec = (
15530 
    None, # 0
15531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15532 
  )
15533 
 
15534 
  def __init__(self, ex=None,):
15535 
    self.ex = ex
15536 
 
15537 
  def read(self, iprot):
15538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15540 
      return
15541 
    iprot.readStructBegin()
15542 
    while True:
15543 
      (fname, ftype, fid) = iprot.readFieldBegin()
15544 
      if ftype == TType.STOP:
15545 
        break
15546 
      if fid == 1:
15547 
        if ftype == TType.STRUCT:
15548 
          self.ex = TransactionServiceException()
15549 
          self.ex.read(iprot)
15550 
        else:
15551 
          iprot.skip(ftype)
15552 
      else:
15553 
        iprot.skip(ftype)
15554 
      iprot.readFieldEnd()
15555 
    iprot.readStructEnd()
15556 
 
15557 
  def write(self, oprot):
15558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15560 
      return
15561 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15562 
    if self.ex is not None:
15563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15564 
      self.ex.write(oprot)
15565 
      oprot.writeFieldEnd()
15566 
    oprot.writeFieldStop()
15567 
    oprot.writeStructEnd()
15568 
 
15569 
  def validate(self):
15570 
    return
15571 
 
15572 
 
15573 
  def __repr__(self):
15574 
    L = ['%s=%r' % (key, value)
15575 
      for key, value in self.__dict__.iteritems()]
15576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15577 
 
15578 
  def __eq__(self, other):
15579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15580 
 
15581 
  def __ne__(self, other):
15582 
    return not (self == other)
15583 
 
4258 rajveer 15584 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15585 
  """
15586 
  Attributes:
4258 rajveer 15587 
   - transactionId
4247 rajveer 15588 
  """
15589 
 
15590 
  thrift_spec = (
15591 
    None, # 0
4258 rajveer 15592 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15593 
  )
15594 
 
4258 rajveer 15595 
  def __init__(self, transactionId=None,):
15596 
    self.transactionId = transactionId
4247 rajveer 15597 
 
15598 
  def read(self, iprot):
15599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15601 
      return
15602 
    iprot.readStructBegin()
15603 
    while True:
15604 
      (fname, ftype, fid) = iprot.readFieldBegin()
15605 
      if ftype == TType.STOP:
15606 
        break
15607 
      if fid == 1:
15608 
        if ftype == TType.I64:
4258 rajveer 15609 
          self.transactionId = iprot.readI64();
4247 rajveer 15610 
        else:
15611 
          iprot.skip(ftype)
15612 
      else:
15613 
        iprot.skip(ftype)
15614 
      iprot.readFieldEnd()
15615 
    iprot.readStructEnd()
15616 
 
15617 
  def write(self, oprot):
15618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15620 
      return
4258 rajveer 15621 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15622 
    if self.transactionId is not None:
15623 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15624 
      oprot.writeI64(self.transactionId)
4247 rajveer 15625 
      oprot.writeFieldEnd()
15626 
    oprot.writeFieldStop()
15627 
    oprot.writeStructEnd()
15628 
 
15629 
  def validate(self):
15630 
    return
15631 
 
15632 
 
15633 
  def __repr__(self):
15634 
    L = ['%s=%r' % (key, value)
15635 
      for key, value in self.__dict__.iteritems()]
15636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15637 
 
15638 
  def __eq__(self, other):
15639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15640 
 
15641 
  def __ne__(self, other):
15642 
    return not (self == other)
15643 
 
4258 rajveer 15644 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15645 
  """
15646 
  Attributes:
15647 
   - ex
15648 
  """
15649 
 
15650 
  thrift_spec = (
15651 
    None, # 0
15652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15653 
  )
15654 
 
15655 
  def __init__(self, ex=None,):
15656 
    self.ex = ex
15657 
 
15658 
  def read(self, iprot):
15659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15661 
      return
15662 
    iprot.readStructBegin()
15663 
    while True:
15664 
      (fname, ftype, fid) = iprot.readFieldBegin()
15665 
      if ftype == TType.STOP:
15666 
        break
15667 
      if fid == 1:
15668 
        if ftype == TType.STRUCT:
15669 
          self.ex = TransactionServiceException()
15670 
          self.ex.read(iprot)
15671 
        else:
15672 
          iprot.skip(ftype)
15673 
      else:
15674 
        iprot.skip(ftype)
15675 
      iprot.readFieldEnd()
15676 
    iprot.readStructEnd()
15677 
 
15678 
  def write(self, oprot):
15679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15681 
      return
4258 rajveer 15682 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15683 
    if self.ex is not None:
15684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15685 
      self.ex.write(oprot)
15686 
      oprot.writeFieldEnd()
15687 
    oprot.writeFieldStop()
15688 
    oprot.writeStructEnd()
15689 
 
15690 
  def validate(self):
15691 
    return
15692 
 
15693 
 
15694 
  def __repr__(self):
15695 
    L = ['%s=%r' % (key, value)
15696 
      for key, value in self.__dict__.iteritems()]
15697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15698 
 
15699 
  def __eq__(self, other):
15700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15701 
 
15702 
  def __ne__(self, other):
15703 
    return not (self == other)
4259 anupam.sin 15704 
 
15705 
class refundTransaction_args:
15706 
  """
15707 
  Attributes:
15708 
   - transactionId
15709 
   - refundedBy
15710 
   - reason
15711 
  """
15712 
 
15713 
  thrift_spec = (
15714 
    None, # 0
15715 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15716 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15717 
    (3, TType.STRING, 'reason', None, None, ), # 3
15718 
  )
15719 
 
15720 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15721 
    self.transactionId = transactionId
15722 
    self.refundedBy = refundedBy
15723 
    self.reason = reason
15724 
 
15725 
  def read(self, iprot):
15726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15728 
      return
15729 
    iprot.readStructBegin()
15730 
    while True:
15731 
      (fname, ftype, fid) = iprot.readFieldBegin()
15732 
      if ftype == TType.STOP:
15733 
        break
15734 
      if fid == 1:
15735 
        if ftype == TType.I64:
15736 
          self.transactionId = iprot.readI64();
15737 
        else:
15738 
          iprot.skip(ftype)
15739 
      elif fid == 2:
15740 
        if ftype == TType.STRING:
15741 
          self.refundedBy = iprot.readString();
15742 
        else:
15743 
          iprot.skip(ftype)
15744 
      elif fid == 3:
15745 
        if ftype == TType.STRING:
15746 
          self.reason = iprot.readString();
15747 
        else:
15748 
          iprot.skip(ftype)
15749 
      else:
15750 
        iprot.skip(ftype)
15751 
      iprot.readFieldEnd()
15752 
    iprot.readStructEnd()
15753 
 
15754 
  def write(self, oprot):
15755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15757 
      return
15758 
    oprot.writeStructBegin('refundTransaction_args')
15759 
    if self.transactionId is not None:
15760 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15761 
      oprot.writeI64(self.transactionId)
15762 
      oprot.writeFieldEnd()
15763 
    if self.refundedBy is not None:
15764 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15765 
      oprot.writeString(self.refundedBy)
15766 
      oprot.writeFieldEnd()
15767 
    if self.reason is not None:
15768 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15769 
      oprot.writeString(self.reason)
15770 
      oprot.writeFieldEnd()
15771 
    oprot.writeFieldStop()
15772 
    oprot.writeStructEnd()
15773 
 
15774 
  def validate(self):
15775 
    return
15776 
 
15777 
 
15778 
  def __repr__(self):
15779 
    L = ['%s=%r' % (key, value)
15780 
      for key, value in self.__dict__.iteritems()]
15781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15782 
 
15783 
  def __eq__(self, other):
15784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15785 
 
15786 
  def __ne__(self, other):
15787 
    return not (self == other)
15788 
 
15789 
class refundTransaction_result:
15790 
  """
15791 
  Attributes:
15792 
   - ex
15793 
  """
15794 
 
15795 
  thrift_spec = (
15796 
    None, # 0
15797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15798 
  )
15799 
 
15800 
  def __init__(self, ex=None,):
15801 
    self.ex = ex
15802 
 
15803 
  def read(self, iprot):
15804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15806 
      return
15807 
    iprot.readStructBegin()
15808 
    while True:
15809 
      (fname, ftype, fid) = iprot.readFieldBegin()
15810 
      if ftype == TType.STOP:
15811 
        break
15812 
      if fid == 1:
15813 
        if ftype == TType.STRUCT:
15814 
          self.ex = TransactionServiceException()
15815 
          self.ex.read(iprot)
15816 
        else:
15817 
          iprot.skip(ftype)
15818 
      else:
15819 
        iprot.skip(ftype)
15820 
      iprot.readFieldEnd()
15821 
    iprot.readStructEnd()
15822 
 
15823 
  def write(self, oprot):
15824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15826 
      return
15827 
    oprot.writeStructBegin('refundTransaction_result')
15828 
    if self.ex is not None:
15829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15830 
      self.ex.write(oprot)
15831 
      oprot.writeFieldEnd()
15832 
    oprot.writeFieldStop()
15833 
    oprot.writeStructEnd()
15834 
 
15835 
  def validate(self):
15836 
    return
15837 
 
15838 
 
15839 
  def __repr__(self):
15840 
    L = ['%s=%r' % (key, value)
15841 
      for key, value in self.__dict__.iteritems()]
15842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15843 
 
15844 
  def __eq__(self, other):
15845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15846 
 
15847 
  def __ne__(self, other):
15848 
    return not (self == other)
4285 rajveer 15849 
 
4324 mandeep.dh 15850 
class updateShipmentAddress_args:
15851 
  """
15852 
  Attributes:
15853 
   - orderId
15854 
   - addressId
15855 
  """
15856 
 
15857 
  thrift_spec = (
15858 
    None, # 0
15859 
    (1, TType.I64, 'orderId', None, None, ), # 1
15860 
    (2, TType.I64, 'addressId', None, None, ), # 2
15861 
  )
15862 
 
15863 
  def __init__(self, orderId=None, addressId=None,):
15864 
    self.orderId = orderId
15865 
    self.addressId = addressId
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 1:
15877 
        if ftype == TType.I64:
15878 
          self.orderId = iprot.readI64();
15879 
        else:
15880 
          iprot.skip(ftype)
15881 
      elif fid == 2:
15882 
        if ftype == TType.I64:
15883 
          self.addressId = iprot.readI64();
15884 
        else:
15885 
          iprot.skip(ftype)
15886 
      else:
15887 
        iprot.skip(ftype)
15888 
      iprot.readFieldEnd()
15889 
    iprot.readStructEnd()
15890 
 
15891 
  def write(self, oprot):
15892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15894 
      return
15895 
    oprot.writeStructBegin('updateShipmentAddress_args')
15896 
    if self.orderId is not None:
15897 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15898 
      oprot.writeI64(self.orderId)
15899 
      oprot.writeFieldEnd()
15900 
    if self.addressId is not None:
15901 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15902 
      oprot.writeI64(self.addressId)
15903 
      oprot.writeFieldEnd()
15904 
    oprot.writeFieldStop()
15905 
    oprot.writeStructEnd()
15906 
 
15907 
  def validate(self):
15908 
    return
15909 
 
15910 
 
15911 
  def __repr__(self):
15912 
    L = ['%s=%r' % (key, value)
15913 
      for key, value in self.__dict__.iteritems()]
15914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15915 
 
15916 
  def __eq__(self, other):
15917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15918 
 
15919 
  def __ne__(self, other):
15920 
    return not (self == other)
15921 
 
15922 
class updateShipmentAddress_result:
15923 
  """
15924 
  Attributes:
15925 
   - ex
15926 
  """
15927 
 
15928 
  thrift_spec = (
15929 
    None, # 0
15930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15931 
  )
15932 
 
15933 
  def __init__(self, ex=None,):
15934 
    self.ex = ex
15935 
 
15936 
  def read(self, iprot):
15937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15939 
      return
15940 
    iprot.readStructBegin()
15941 
    while True:
15942 
      (fname, ftype, fid) = iprot.readFieldBegin()
15943 
      if ftype == TType.STOP:
15944 
        break
15945 
      if fid == 1:
15946 
        if ftype == TType.STRUCT:
15947 
          self.ex = TransactionServiceException()
15948 
          self.ex.read(iprot)
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      else:
15952 
        iprot.skip(ftype)
15953 
      iprot.readFieldEnd()
15954 
    iprot.readStructEnd()
15955 
 
15956 
  def write(self, oprot):
15957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15959 
      return
15960 
    oprot.writeStructBegin('updateShipmentAddress_result')
15961 
    if self.ex is not None:
15962 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15963 
      self.ex.write(oprot)
15964 
      oprot.writeFieldEnd()
15965 
    oprot.writeFieldStop()
15966 
    oprot.writeStructEnd()
15967 
 
15968 
  def validate(self):
15969 
    return
15970 
 
15971 
 
15972 
  def __repr__(self):
15973 
    L = ['%s=%r' % (key, value)
15974 
      for key, value in self.__dict__.iteritems()]
15975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15976 
 
15977 
  def __eq__(self, other):
15978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15979 
 
15980 
  def __ne__(self, other):
15981 
    return not (self == other)
15982 
 
4285 rajveer 15983 
class acceptOrdersForItemId_args:
15984 
  """
15985 
  Attributes:
15986 
   - itemId
15987 
   - inventory
15988 
  """
15989 
 
15990 
  thrift_spec = (
15991 
    None, # 0
15992 
    (1, TType.I64, 'itemId', None, None, ), # 1
15993 
    (2, TType.I64, 'inventory', None, None, ), # 2
15994 
  )
15995 
 
15996 
  def __init__(self, itemId=None, inventory=None,):
15997 
    self.itemId = itemId
15998 
    self.inventory = inventory
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      if fid == 1:
16010 
        if ftype == TType.I64:
16011 
          self.itemId = iprot.readI64();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      elif fid == 2:
16015 
        if ftype == TType.I64:
16016 
          self.inventory = iprot.readI64();
16017 
        else:
16018 
          iprot.skip(ftype)
16019 
      else:
16020 
        iprot.skip(ftype)
16021 
      iprot.readFieldEnd()
16022 
    iprot.readStructEnd()
16023 
 
16024 
  def write(self, oprot):
16025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16027 
      return
16028 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16029 
    if self.itemId is not None:
16030 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16031 
      oprot.writeI64(self.itemId)
16032 
      oprot.writeFieldEnd()
16033 
    if self.inventory is not None:
16034 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16035 
      oprot.writeI64(self.inventory)
16036 
      oprot.writeFieldEnd()
16037 
    oprot.writeFieldStop()
16038 
    oprot.writeStructEnd()
16039 
 
16040 
  def validate(self):
16041 
    return
16042 
 
16043 
 
16044 
  def __repr__(self):
16045 
    L = ['%s=%r' % (key, value)
16046 
      for key, value in self.__dict__.iteritems()]
16047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16048 
 
16049 
  def __eq__(self, other):
16050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16051 
 
16052 
  def __ne__(self, other):
16053 
    return not (self == other)
16054 
 
16055 
class acceptOrdersForItemId_result:
16056 
  """
16057 
  Attributes:
16058 
   - success
16059 
   - ex
16060 
  """
16061 
 
16062 
  thrift_spec = (
16063 
    (0, TType.BOOL, 'success', None, None, ), # 0
16064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16065 
  )
16066 
 
16067 
  def __init__(self, success=None, ex=None,):
16068 
    self.success = success
16069 
    self.ex = ex
16070 
 
16071 
  def read(self, iprot):
16072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16074 
      return
16075 
    iprot.readStructBegin()
16076 
    while True:
16077 
      (fname, ftype, fid) = iprot.readFieldBegin()
16078 
      if ftype == TType.STOP:
16079 
        break
16080 
      if fid == 0:
16081 
        if ftype == TType.BOOL:
16082 
          self.success = iprot.readBool();
16083 
        else:
16084 
          iprot.skip(ftype)
16085 
      elif fid == 1:
16086 
        if ftype == TType.STRUCT:
16087 
          self.ex = TransactionServiceException()
16088 
          self.ex.read(iprot)
16089 
        else:
16090 
          iprot.skip(ftype)
16091 
      else:
16092 
        iprot.skip(ftype)
16093 
      iprot.readFieldEnd()
16094 
    iprot.readStructEnd()
16095 
 
16096 
  def write(self, oprot):
16097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16099 
      return
16100 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16101 
    if self.success is not None:
16102 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16103 
      oprot.writeBool(self.success)
16104 
      oprot.writeFieldEnd()
16105 
    if self.ex is not None:
16106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16107 
      self.ex.write(oprot)
16108 
      oprot.writeFieldEnd()
16109 
    oprot.writeFieldStop()
16110 
    oprot.writeStructEnd()
16111 
 
16112 
  def validate(self):
16113 
    return
16114 
 
16115 
 
16116 
  def __repr__(self):
16117 
    L = ['%s=%r' % (key, value)
16118 
      for key, value in self.__dict__.iteritems()]
16119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16120 
 
16121 
  def __eq__(self, other):
16122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16123 
 
16124 
  def __ne__(self, other):
16125 
    return not (self == other)
4303 rajveer 16126 
 
16127 
class markOrdersAsPORaised_args:
16128 
  """
16129 
  Attributes:
16130 
   - vendorId
16131 
   - itemId
16132 
   - quantity
16133 
   - estimate
4369 rajveer 16134 
   - isReminder
4303 rajveer 16135 
  """
16136 
 
16137 
  thrift_spec = (
16138 
    None, # 0
16139 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16140 
    (2, TType.I64, 'itemId', None, None, ), # 2
16141 
    (3, TType.I64, 'quantity', None, None, ), # 3
16142 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16143 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16144 
  )
16145 
 
4369 rajveer 16146 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16147 
    self.vendorId = vendorId
16148 
    self.itemId = itemId
16149 
    self.quantity = quantity
16150 
    self.estimate = estimate
4369 rajveer 16151 
    self.isReminder = isReminder
4303 rajveer 16152 
 
16153 
  def read(self, iprot):
16154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16156 
      return
16157 
    iprot.readStructBegin()
16158 
    while True:
16159 
      (fname, ftype, fid) = iprot.readFieldBegin()
16160 
      if ftype == TType.STOP:
16161 
        break
16162 
      if fid == 1:
16163 
        if ftype == TType.I64:
16164 
          self.vendorId = iprot.readI64();
16165 
        else:
16166 
          iprot.skip(ftype)
16167 
      elif fid == 2:
16168 
        if ftype == TType.I64:
16169 
          self.itemId = iprot.readI64();
16170 
        else:
16171 
          iprot.skip(ftype)
16172 
      elif fid == 3:
16173 
        if ftype == TType.I64:
16174 
          self.quantity = iprot.readI64();
16175 
        else:
16176 
          iprot.skip(ftype)
16177 
      elif fid == 4:
16178 
        if ftype == TType.I64:
16179 
          self.estimate = iprot.readI64();
16180 
        else:
16181 
          iprot.skip(ftype)
4369 rajveer 16182 
      elif fid == 5:
16183 
        if ftype == TType.BOOL:
16184 
          self.isReminder = iprot.readBool();
16185 
        else:
16186 
          iprot.skip(ftype)
4303 rajveer 16187 
      else:
16188 
        iprot.skip(ftype)
16189 
      iprot.readFieldEnd()
16190 
    iprot.readStructEnd()
16191 
 
16192 
  def write(self, oprot):
16193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16195 
      return
16196 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16197 
    if self.vendorId is not None:
16198 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16199 
      oprot.writeI64(self.vendorId)
16200 
      oprot.writeFieldEnd()
16201 
    if self.itemId is not None:
16202 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16203 
      oprot.writeI64(self.itemId)
16204 
      oprot.writeFieldEnd()
16205 
    if self.quantity is not None:
16206 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16207 
      oprot.writeI64(self.quantity)
16208 
      oprot.writeFieldEnd()
16209 
    if self.estimate is not None:
16210 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16211 
      oprot.writeI64(self.estimate)
16212 
      oprot.writeFieldEnd()
4369 rajveer 16213 
    if self.isReminder is not None:
16214 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16215 
      oprot.writeBool(self.isReminder)
16216 
      oprot.writeFieldEnd()
4303 rajveer 16217 
    oprot.writeFieldStop()
16218 
    oprot.writeStructEnd()
16219 
 
16220 
  def validate(self):
16221 
    return
16222 
 
16223 
 
16224 
  def __repr__(self):
16225 
    L = ['%s=%r' % (key, value)
16226 
      for key, value in self.__dict__.iteritems()]
16227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16228 
 
16229 
  def __eq__(self, other):
16230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16231 
 
16232 
  def __ne__(self, other):
16233 
    return not (self == other)
16234 
 
16235 
class markOrdersAsPORaised_result:
16236 
  """
16237 
  Attributes:
16238 
   - ex
16239 
  """
16240 
 
16241 
  thrift_spec = (
16242 
    None, # 0
16243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16244 
  )
16245 
 
16246 
  def __init__(self, ex=None,):
16247 
    self.ex = ex
16248 
 
16249 
  def read(self, iprot):
16250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16252 
      return
16253 
    iprot.readStructBegin()
16254 
    while True:
16255 
      (fname, ftype, fid) = iprot.readFieldBegin()
16256 
      if ftype == TType.STOP:
16257 
        break
16258 
      if fid == 1:
16259 
        if ftype == TType.STRUCT:
16260 
          self.ex = TransactionServiceException()
16261 
          self.ex.read(iprot)
16262 
        else:
16263 
          iprot.skip(ftype)
16264 
      else:
16265 
        iprot.skip(ftype)
16266 
      iprot.readFieldEnd()
16267 
    iprot.readStructEnd()
16268 
 
16269 
  def write(self, oprot):
16270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16272 
      return
16273 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16274 
    if self.ex is not None:
16275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16276 
      self.ex.write(oprot)
16277 
      oprot.writeFieldEnd()
16278 
    oprot.writeFieldStop()
16279 
    oprot.writeStructEnd()
16280 
 
16281 
  def validate(self):
16282 
    return
16283 
 
16284 
 
16285 
  def __repr__(self):
16286 
    L = ['%s=%r' % (key, value)
16287 
      for key, value in self.__dict__.iteritems()]
16288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16289 
 
16290 
  def __eq__(self, other):
16291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16292 
 
16293 
  def __ne__(self, other):
16294 
    return not (self == other)
16295 
 
16296 
class markOrdersAsReversalInitiated_args:
16297 
  """
16298 
  Attributes:
16299 
   - vendorId
16300 
   - itemId
16301 
   - quantity
16302 
   - estimate
4369 rajveer 16303 
   - isReminder
4303 rajveer 16304 
  """
16305 
 
16306 
  thrift_spec = (
16307 
    None, # 0
16308 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16309 
    (2, TType.I64, 'itemId', None, None, ), # 2
16310 
    (3, TType.I64, 'quantity', None, None, ), # 3
16311 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16312 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16313 
  )
16314 
 
4369 rajveer 16315 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16316 
    self.vendorId = vendorId
16317 
    self.itemId = itemId
16318 
    self.quantity = quantity
16319 
    self.estimate = estimate
4369 rajveer 16320 
    self.isReminder = isReminder
4303 rajveer 16321 
 
16322 
  def read(self, iprot):
16323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16325 
      return
16326 
    iprot.readStructBegin()
16327 
    while True:
16328 
      (fname, ftype, fid) = iprot.readFieldBegin()
16329 
      if ftype == TType.STOP:
16330 
        break
16331 
      if fid == 1:
16332 
        if ftype == TType.I64:
16333 
          self.vendorId = iprot.readI64();
16334 
        else:
16335 
          iprot.skip(ftype)
16336 
      elif fid == 2:
16337 
        if ftype == TType.I64:
16338 
          self.itemId = iprot.readI64();
16339 
        else:
16340 
          iprot.skip(ftype)
16341 
      elif fid == 3:
16342 
        if ftype == TType.I64:
16343 
          self.quantity = iprot.readI64();
16344 
        else:
16345 
          iprot.skip(ftype)
16346 
      elif fid == 4:
16347 
        if ftype == TType.I64:
16348 
          self.estimate = iprot.readI64();
16349 
        else:
16350 
          iprot.skip(ftype)
4369 rajveer 16351 
      elif fid == 5:
16352 
        if ftype == TType.BOOL:
16353 
          self.isReminder = iprot.readBool();
16354 
        else:
16355 
          iprot.skip(ftype)
4303 rajveer 16356 
      else:
16357 
        iprot.skip(ftype)
16358 
      iprot.readFieldEnd()
16359 
    iprot.readStructEnd()
16360 
 
16361 
  def write(self, oprot):
16362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16364 
      return
16365 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16366 
    if self.vendorId is not None:
16367 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16368 
      oprot.writeI64(self.vendorId)
16369 
      oprot.writeFieldEnd()
16370 
    if self.itemId is not None:
16371 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16372 
      oprot.writeI64(self.itemId)
16373 
      oprot.writeFieldEnd()
16374 
    if self.quantity is not None:
16375 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16376 
      oprot.writeI64(self.quantity)
16377 
      oprot.writeFieldEnd()
16378 
    if self.estimate is not None:
16379 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16380 
      oprot.writeI64(self.estimate)
16381 
      oprot.writeFieldEnd()
4369 rajveer 16382 
    if self.isReminder is not None:
16383 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16384 
      oprot.writeBool(self.isReminder)
16385 
      oprot.writeFieldEnd()
4303 rajveer 16386 
    oprot.writeFieldStop()
16387 
    oprot.writeStructEnd()
16388 
 
16389 
  def validate(self):
16390 
    return
16391 
 
16392 
 
16393 
  def __repr__(self):
16394 
    L = ['%s=%r' % (key, value)
16395 
      for key, value in self.__dict__.iteritems()]
16396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16397 
 
16398 
  def __eq__(self, other):
16399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16400 
 
16401 
  def __ne__(self, other):
16402 
    return not (self == other)
16403 
 
16404 
class markOrdersAsReversalInitiated_result:
16405 
  """
16406 
  Attributes:
16407 
   - ex
16408 
  """
16409 
 
16410 
  thrift_spec = (
16411 
    None, # 0
16412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16413 
  )
16414 
 
16415 
  def __init__(self, ex=None,):
16416 
    self.ex = ex
16417 
 
16418 
  def read(self, iprot):
16419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16421 
      return
16422 
    iprot.readStructBegin()
16423 
    while True:
16424 
      (fname, ftype, fid) = iprot.readFieldBegin()
16425 
      if ftype == TType.STOP:
16426 
        break
16427 
      if fid == 1:
16428 
        if ftype == TType.STRUCT:
16429 
          self.ex = TransactionServiceException()
16430 
          self.ex.read(iprot)
16431 
        else:
16432 
          iprot.skip(ftype)
16433 
      else:
16434 
        iprot.skip(ftype)
16435 
      iprot.readFieldEnd()
16436 
    iprot.readStructEnd()
16437 
 
16438 
  def write(self, oprot):
16439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16441 
      return
16442 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16443 
    if self.ex is not None:
16444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16445 
      self.ex.write(oprot)
16446 
      oprot.writeFieldEnd()
16447 
    oprot.writeFieldStop()
16448 
    oprot.writeStructEnd()
16449 
 
16450 
  def validate(self):
16451 
    return
16452 
 
16453 
 
16454 
  def __repr__(self):
16455 
    L = ['%s=%r' % (key, value)
16456 
      for key, value in self.__dict__.iteritems()]
16457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16458 
 
16459 
  def __eq__(self, other):
16460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16461 
 
16462 
  def __ne__(self, other):
16463 
    return not (self == other)
16464 
 
16465 
class markOrdersAsNotAvailabke_args:
16466 
  """
16467 
  Attributes:
16468 
   - vendorId
16469 
   - itemId
16470 
   - quantity
16471 
   - estimate
4369 rajveer 16472 
   - isReminder
4303 rajveer 16473 
  """
16474 
 
16475 
  thrift_spec = (
16476 
    None, # 0
16477 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16478 
    (2, TType.I64, 'itemId', None, None, ), # 2
16479 
    (3, TType.I64, 'quantity', None, None, ), # 3
16480 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16481 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16482 
  )
16483 
 
4369 rajveer 16484 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16485 
    self.vendorId = vendorId
16486 
    self.itemId = itemId
16487 
    self.quantity = quantity
16488 
    self.estimate = estimate
4369 rajveer 16489 
    self.isReminder = isReminder
4303 rajveer 16490 
 
16491 
  def read(self, iprot):
16492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16494 
      return
16495 
    iprot.readStructBegin()
16496 
    while True:
16497 
      (fname, ftype, fid) = iprot.readFieldBegin()
16498 
      if ftype == TType.STOP:
16499 
        break
16500 
      if fid == 1:
16501 
        if ftype == TType.I64:
16502 
          self.vendorId = iprot.readI64();
16503 
        else:
16504 
          iprot.skip(ftype)
16505 
      elif fid == 2:
16506 
        if ftype == TType.I64:
16507 
          self.itemId = iprot.readI64();
16508 
        else:
16509 
          iprot.skip(ftype)
16510 
      elif fid == 3:
16511 
        if ftype == TType.I64:
16512 
          self.quantity = iprot.readI64();
16513 
        else:
16514 
          iprot.skip(ftype)
16515 
      elif fid == 4:
16516 
        if ftype == TType.I64:
16517 
          self.estimate = iprot.readI64();
16518 
        else:
16519 
          iprot.skip(ftype)
4369 rajveer 16520 
      elif fid == 5:
16521 
        if ftype == TType.BOOL:
16522 
          self.isReminder = iprot.readBool();
16523 
        else:
16524 
          iprot.skip(ftype)
4303 rajveer 16525 
      else:
16526 
        iprot.skip(ftype)
16527 
      iprot.readFieldEnd()
16528 
    iprot.readStructEnd()
16529 
 
16530 
  def write(self, oprot):
16531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16533 
      return
16534 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16535 
    if self.vendorId is not None:
16536 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16537 
      oprot.writeI64(self.vendorId)
16538 
      oprot.writeFieldEnd()
16539 
    if self.itemId is not None:
16540 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16541 
      oprot.writeI64(self.itemId)
16542 
      oprot.writeFieldEnd()
16543 
    if self.quantity is not None:
16544 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16545 
      oprot.writeI64(self.quantity)
16546 
      oprot.writeFieldEnd()
16547 
    if self.estimate is not None:
16548 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16549 
      oprot.writeI64(self.estimate)
16550 
      oprot.writeFieldEnd()
4369 rajveer 16551 
    if self.isReminder is not None:
16552 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16553 
      oprot.writeBool(self.isReminder)
16554 
      oprot.writeFieldEnd()
4303 rajveer 16555 
    oprot.writeFieldStop()
16556 
    oprot.writeStructEnd()
16557 
 
16558 
  def validate(self):
16559 
    return
16560 
 
16561 
 
16562 
  def __repr__(self):
16563 
    L = ['%s=%r' % (key, value)
16564 
      for key, value in self.__dict__.iteritems()]
16565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16566 
 
16567 
  def __eq__(self, other):
16568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16569 
 
16570 
  def __ne__(self, other):
16571 
    return not (self == other)
16572 
 
16573 
class markOrdersAsNotAvailabke_result:
16574 
  """
16575 
  Attributes:
16576 
   - ex
16577 
  """
16578 
 
16579 
  thrift_spec = (
16580 
    None, # 0
16581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16582 
  )
16583 
 
16584 
  def __init__(self, ex=None,):
16585 
    self.ex = ex
16586 
 
16587 
  def read(self, iprot):
16588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16590 
      return
16591 
    iprot.readStructBegin()
16592 
    while True:
16593 
      (fname, ftype, fid) = iprot.readFieldBegin()
16594 
      if ftype == TType.STOP:
16595 
        break
16596 
      if fid == 1:
16597 
        if ftype == TType.STRUCT:
16598 
          self.ex = TransactionServiceException()
16599 
          self.ex.read(iprot)
16600 
        else:
16601 
          iprot.skip(ftype)
16602 
      else:
16603 
        iprot.skip(ftype)
16604 
      iprot.readFieldEnd()
16605 
    iprot.readStructEnd()
16606 
 
16607 
  def write(self, oprot):
16608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16610 
      return
16611 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16612 
    if self.ex is not None:
16613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16614 
      self.ex.write(oprot)
16615 
      oprot.writeFieldEnd()
16616 
    oprot.writeFieldStop()
16617 
    oprot.writeStructEnd()
16618 
 
16619 
  def validate(self):
16620 
    return
16621 
 
16622 
 
16623 
  def __repr__(self):
16624 
    L = ['%s=%r' % (key, value)
16625 
      for key, value in self.__dict__.iteritems()]
16626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16627 
 
16628 
  def __eq__(self, other):
16629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16630 
 
16631 
  def __ne__(self, other):
16632 
    return not (self == other)
4369 rajveer 16633 
 
16634 
class markOrdersAsTimeout_args:
16635 
  """
16636 
  Attributes:
16637 
   - vendorId
16638 
  """
16639 
 
16640 
  thrift_spec = (
16641 
    None, # 0
16642 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16643 
  )
16644 
 
16645 
  def __init__(self, vendorId=None,):
16646 
    self.vendorId = vendorId
16647 
 
16648 
  def read(self, iprot):
16649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16651 
      return
16652 
    iprot.readStructBegin()
16653 
    while True:
16654 
      (fname, ftype, fid) = iprot.readFieldBegin()
16655 
      if ftype == TType.STOP:
16656 
        break
16657 
      if fid == 1:
16658 
        if ftype == TType.I64:
16659 
          self.vendorId = iprot.readI64();
16660 
        else:
16661 
          iprot.skip(ftype)
16662 
      else:
16663 
        iprot.skip(ftype)
16664 
      iprot.readFieldEnd()
16665 
    iprot.readStructEnd()
16666 
 
16667 
  def write(self, oprot):
16668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16670 
      return
16671 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16672 
    if self.vendorId is not None:
16673 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16674 
      oprot.writeI64(self.vendorId)
16675 
      oprot.writeFieldEnd()
16676 
    oprot.writeFieldStop()
16677 
    oprot.writeStructEnd()
16678 
 
16679 
  def validate(self):
16680 
    return
16681 
 
16682 
 
16683 
  def __repr__(self):
16684 
    L = ['%s=%r' % (key, value)
16685 
      for key, value in self.__dict__.iteritems()]
16686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16687 
 
16688 
  def __eq__(self, other):
16689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16690 
 
16691 
  def __ne__(self, other):
16692 
    return not (self == other)
16693 
 
16694 
class markOrdersAsTimeout_result:
16695 
  """
16696 
  Attributes:
16697 
   - success
16698 
   - ex
16699 
  """
16700 
 
16701 
  thrift_spec = (
16702 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16704 
  )
16705 
 
16706 
  def __init__(self, success=None, ex=None,):
16707 
    self.success = success
16708 
    self.ex = ex
16709 
 
16710 
  def read(self, iprot):
16711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16713 
      return
16714 
    iprot.readStructBegin()
16715 
    while True:
16716 
      (fname, ftype, fid) = iprot.readFieldBegin()
16717 
      if ftype == TType.STOP:
16718 
        break
16719 
      if fid == 0:
16720 
        if ftype == TType.MAP:
16721 
          self.success = {}
4586 mandeep.dh 16722 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16723 
          for _i279 in xrange(_size275):
16724 
            _key280 = iprot.readI32();
16725 
            _val281 = TimeoutSummary()
16726 
            _val281.read(iprot)
16727 
            self.success[_key280] = _val281
4369 rajveer 16728 
          iprot.readMapEnd()
16729 
        else:
16730 
          iprot.skip(ftype)
16731 
      elif fid == 1:
16732 
        if ftype == TType.STRUCT:
16733 
          self.ex = TransactionServiceException()
16734 
          self.ex.read(iprot)
16735 
        else:
16736 
          iprot.skip(ftype)
16737 
      else:
16738 
        iprot.skip(ftype)
16739 
      iprot.readFieldEnd()
16740 
    iprot.readStructEnd()
16741 
 
16742 
  def write(self, oprot):
16743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16745 
      return
16746 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16747 
    if self.success is not None:
16748 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16749 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16750 
      for kiter282,viter283 in self.success.items():
16751 
        oprot.writeI32(kiter282)
16752 
        viter283.write(oprot)
4369 rajveer 16753 
      oprot.writeMapEnd()
16754 
      oprot.writeFieldEnd()
16755 
    if self.ex is not None:
16756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16757 
      self.ex.write(oprot)
16758 
      oprot.writeFieldEnd()
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
4386 anupam.sin 16776 
 
4662 rajveer 16777 
class markOrderAsLostInTransit_args:
16778 
  """
16779 
  Attributes:
16780 
   - orderId
16781 
  """
16782 
 
16783 
  thrift_spec = (
16784 
    None, # 0
16785 
    (1, TType.I64, 'orderId', None, None, ), # 1
16786 
  )
16787 
 
16788 
  def __init__(self, orderId=None,):
16789 
    self.orderId = orderId
16790 
 
16791 
  def read(self, iprot):
16792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16794 
      return
16795 
    iprot.readStructBegin()
16796 
    while True:
16797 
      (fname, ftype, fid) = iprot.readFieldBegin()
16798 
      if ftype == TType.STOP:
16799 
        break
16800 
      if fid == 1:
16801 
        if ftype == TType.I64:
16802 
          self.orderId = iprot.readI64();
16803 
        else:
16804 
          iprot.skip(ftype)
16805 
      else:
16806 
        iprot.skip(ftype)
16807 
      iprot.readFieldEnd()
16808 
    iprot.readStructEnd()
16809 
 
16810 
  def write(self, oprot):
16811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16813 
      return
16814 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
16815 
    if self.orderId is not None:
16816 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16817 
      oprot.writeI64(self.orderId)
16818 
      oprot.writeFieldEnd()
16819 
    oprot.writeFieldStop()
16820 
    oprot.writeStructEnd()
16821 
 
16822 
  def validate(self):
16823 
    return
16824 
 
16825 
 
16826 
  def __repr__(self):
16827 
    L = ['%s=%r' % (key, value)
16828 
      for key, value in self.__dict__.iteritems()]
16829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16830 
 
16831 
  def __eq__(self, other):
16832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16833 
 
16834 
  def __ne__(self, other):
16835 
    return not (self == other)
16836 
 
16837 
class markOrderAsLostInTransit_result:
16838 
  """
16839 
  Attributes:
16840 
   - success
16841 
   - ex
16842 
  """
16843 
 
16844 
  thrift_spec = (
16845 
    (0, TType.BOOL, 'success', None, None, ), # 0
16846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16847 
  )
16848 
 
16849 
  def __init__(self, success=None, ex=None,):
16850 
    self.success = success
16851 
    self.ex = ex
16852 
 
16853 
  def read(self, iprot):
16854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16856 
      return
16857 
    iprot.readStructBegin()
16858 
    while True:
16859 
      (fname, ftype, fid) = iprot.readFieldBegin()
16860 
      if ftype == TType.STOP:
16861 
        break
16862 
      if fid == 0:
16863 
        if ftype == TType.BOOL:
16864 
          self.success = iprot.readBool();
16865 
        else:
16866 
          iprot.skip(ftype)
16867 
      elif fid == 1:
16868 
        if ftype == TType.STRUCT:
16869 
          self.ex = TransactionServiceException()
16870 
          self.ex.read(iprot)
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      else:
16874 
        iprot.skip(ftype)
16875 
      iprot.readFieldEnd()
16876 
    iprot.readStructEnd()
16877 
 
16878 
  def write(self, oprot):
16879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16881 
      return
16882 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
16883 
    if self.success is not None:
16884 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16885 
      oprot.writeBool(self.success)
16886 
      oprot.writeFieldEnd()
16887 
    if self.ex is not None:
16888 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16889 
      self.ex.write(oprot)
16890 
      oprot.writeFieldEnd()
16891 
    oprot.writeFieldStop()
16892 
    oprot.writeStructEnd()
16893 
 
16894 
  def validate(self):
16895 
    return
16896 
 
16897 
 
16898 
  def __repr__(self):
16899 
    L = ['%s=%r' % (key, value)
16900 
      for key, value in self.__dict__.iteritems()]
16901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16902 
 
16903 
  def __eq__(self, other):
16904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16905 
 
16906 
  def __ne__(self, other):
16907 
    return not (self == other)
16908 
 
4386 anupam.sin 16909 
class getOrderForAwb_args:
16910 
  """
16911 
  Attributes:
16912 
   - awb
16913 
  """
16914 
 
16915 
  thrift_spec = (
16916 
    None, # 0
16917 
    (1, TType.STRING, 'awb', None, None, ), # 1
16918 
  )
16919 
 
16920 
  def __init__(self, awb=None,):
16921 
    self.awb = awb
16922 
 
16923 
  def read(self, iprot):
16924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16926 
      return
16927 
    iprot.readStructBegin()
16928 
    while True:
16929 
      (fname, ftype, fid) = iprot.readFieldBegin()
16930 
      if ftype == TType.STOP:
16931 
        break
16932 
      if fid == 1:
16933 
        if ftype == TType.STRING:
16934 
          self.awb = iprot.readString();
16935 
        else:
16936 
          iprot.skip(ftype)
16937 
      else:
16938 
        iprot.skip(ftype)
16939 
      iprot.readFieldEnd()
16940 
    iprot.readStructEnd()
16941 
 
16942 
  def write(self, oprot):
16943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16945 
      return
16946 
    oprot.writeStructBegin('getOrderForAwb_args')
16947 
    if self.awb is not None:
16948 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16949 
      oprot.writeString(self.awb)
16950 
      oprot.writeFieldEnd()
16951 
    oprot.writeFieldStop()
16952 
    oprot.writeStructEnd()
16953 
 
16954 
  def validate(self):
16955 
    return
16956 
 
16957 
 
16958 
  def __repr__(self):
16959 
    L = ['%s=%r' % (key, value)
16960 
      for key, value in self.__dict__.iteritems()]
16961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16962 
 
16963 
  def __eq__(self, other):
16964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16965 
 
16966 
  def __ne__(self, other):
16967 
    return not (self == other)
16968 
 
16969 
class getOrderForAwb_result:
16970 
  """
16971 
  Attributes:
16972 
   - success
16973 
   - ex
16974 
  """
16975 
 
16976 
  thrift_spec = (
16977 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16978 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16979 
  )
16980 
 
16981 
  def __init__(self, success=None, ex=None,):
16982 
    self.success = success
16983 
    self.ex = ex
16984 
 
16985 
  def read(self, iprot):
16986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16988 
      return
16989 
    iprot.readStructBegin()
16990 
    while True:
16991 
      (fname, ftype, fid) = iprot.readFieldBegin()
16992 
      if ftype == TType.STOP:
16993 
        break
16994 
      if fid == 0:
16995 
        if ftype == TType.STRUCT:
16996 
          self.success = Order()
16997 
          self.success.read(iprot)
16998 
        else:
16999 
          iprot.skip(ftype)
17000 
      elif fid == 1:
17001 
        if ftype == TType.STRUCT:
17002 
          self.ex = TransactionServiceException()
17003 
          self.ex.read(iprot)
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      else:
17007 
        iprot.skip(ftype)
17008 
      iprot.readFieldEnd()
17009 
    iprot.readStructEnd()
17010 
 
17011 
  def write(self, oprot):
17012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17014 
      return
17015 
    oprot.writeStructBegin('getOrderForAwb_result')
17016 
    if self.success is not None:
17017 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17018 
      self.success.write(oprot)
17019 
      oprot.writeFieldEnd()
17020 
    if self.ex is not None:
17021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17022 
      self.ex.write(oprot)
17023 
      oprot.writeFieldEnd()
17024 
    oprot.writeFieldStop()
17025 
    oprot.writeStructEnd()
17026 
 
17027 
  def validate(self):
17028 
    return
17029 
 
17030 
 
17031 
  def __repr__(self):
17032 
    L = ['%s=%r' % (key, value)
17033 
      for key, value in self.__dict__.iteritems()]
17034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17035 
 
17036 
  def __eq__(self, other):
17037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17038 
 
17039 
  def __ne__(self, other):
17040 
    return not (self == other)
4506 phani.kuma 17041 
 
17042 
class getOrdersForProviderForStatus_args:
17043 
  """
17044 
  Attributes:
17045 
   - logistics_provider_id
17046 
   - order_status
17047 
  """
17048 
 
17049 
  thrift_spec = (
17050 
    None, # 0
17051 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17052 
    (2, TType.I32, 'order_status', None, None, ), # 2
17053 
  )
17054 
 
17055 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17056 
    self.logistics_provider_id = logistics_provider_id
17057 
    self.order_status = order_status
17058 
 
17059 
  def read(self, iprot):
17060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17062 
      return
17063 
    iprot.readStructBegin()
17064 
    while True:
17065 
      (fname, ftype, fid) = iprot.readFieldBegin()
17066 
      if ftype == TType.STOP:
17067 
        break
17068 
      if fid == 1:
17069 
        if ftype == TType.I64:
17070 
          self.logistics_provider_id = iprot.readI64();
17071 
        else:
17072 
          iprot.skip(ftype)
17073 
      elif fid == 2:
17074 
        if ftype == TType.I32:
17075 
          self.order_status = iprot.readI32();
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      else:
17079 
        iprot.skip(ftype)
17080 
      iprot.readFieldEnd()
17081 
    iprot.readStructEnd()
17082 
 
17083 
  def write(self, oprot):
17084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17086 
      return
17087 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17088 
    if self.logistics_provider_id is not None:
17089 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17090 
      oprot.writeI64(self.logistics_provider_id)
17091 
      oprot.writeFieldEnd()
17092 
    if self.order_status is not None:
17093 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17094 
      oprot.writeI32(self.order_status)
17095 
      oprot.writeFieldEnd()
17096 
    oprot.writeFieldStop()
17097 
    oprot.writeStructEnd()
17098 
 
17099 
  def validate(self):
17100 
    return
17101 
 
17102 
 
17103 
  def __repr__(self):
17104 
    L = ['%s=%r' % (key, value)
17105 
      for key, value in self.__dict__.iteritems()]
17106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17107 
 
17108 
  def __eq__(self, other):
17109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17110 
 
17111 
  def __ne__(self, other):
17112 
    return not (self == other)
17113 
 
17114 
class getOrdersForProviderForStatus_result:
17115 
  """
17116 
  Attributes:
17117 
   - success
17118 
   - ex
17119 
  """
17120 
 
17121 
  thrift_spec = (
17122 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17124 
  )
17125 
 
17126 
  def __init__(self, success=None, ex=None,):
17127 
    self.success = success
17128 
    self.ex = ex
17129 
 
17130 
  def read(self, iprot):
17131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17133 
      return
17134 
    iprot.readStructBegin()
17135 
    while True:
17136 
      (fname, ftype, fid) = iprot.readFieldBegin()
17137 
      if ftype == TType.STOP:
17138 
        break
17139 
      if fid == 0:
17140 
        if ftype == TType.LIST:
17141 
          self.success = []
4586 mandeep.dh 17142 
          (_etype287, _size284) = iprot.readListBegin()
17143 
          for _i288 in xrange(_size284):
17144 
            _elem289 = Order()
17145 
            _elem289.read(iprot)
17146 
            self.success.append(_elem289)
4506 phani.kuma 17147 
          iprot.readListEnd()
17148 
        else:
17149 
          iprot.skip(ftype)
17150 
      elif fid == 1:
17151 
        if ftype == TType.STRUCT:
17152 
          self.ex = TransactionServiceException()
17153 
          self.ex.read(iprot)
17154 
        else:
17155 
          iprot.skip(ftype)
17156 
      else:
17157 
        iprot.skip(ftype)
17158 
      iprot.readFieldEnd()
17159 
    iprot.readStructEnd()
17160 
 
17161 
  def write(self, oprot):
17162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17164 
      return
17165 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17166 
    if self.success is not None:
17167 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17168 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 17169 
      for iter290 in self.success:
17170 
        iter290.write(oprot)
4506 phani.kuma 17171 
      oprot.writeListEnd()
17172 
      oprot.writeFieldEnd()
17173 
    if self.ex is not None:
17174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17175 
      self.ex.write(oprot)
17176 
      oprot.writeFieldEnd()
17177 
    oprot.writeFieldStop()
17178 
    oprot.writeStructEnd()
17179 
 
17180 
  def validate(self):
17181 
    return
17182 
 
17183 
 
17184 
  def __repr__(self):
17185 
    L = ['%s=%r' % (key, value)
17186 
      for key, value in self.__dict__.iteritems()]
17187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17188 
 
17189 
  def __eq__(self, other):
17190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17191 
 
17192 
  def __ne__(self, other):
17193 
    return not (self == other)
4600 varun.gupt 17194 
 
17195 
class getBilledOrdersForVendor_args:
17196 
  """
17197 
  Attributes:
17198 
   - vendorId
17199 
   - billingDateFrom
17200 
   - billingDateTo
17201 
  """
17202 
 
17203 
  thrift_spec = (
17204 
    None, # 0
17205 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17206 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17207 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17208 
  )
17209 
 
17210 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17211 
    self.vendorId = vendorId
17212 
    self.billingDateFrom = billingDateFrom
17213 
    self.billingDateTo = billingDateTo
17214 
 
17215 
  def read(self, iprot):
17216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17218 
      return
17219 
    iprot.readStructBegin()
17220 
    while True:
17221 
      (fname, ftype, fid) = iprot.readFieldBegin()
17222 
      if ftype == TType.STOP:
17223 
        break
17224 
      if fid == 1:
17225 
        if ftype == TType.I64:
17226 
          self.vendorId = iprot.readI64();
17227 
        else:
17228 
          iprot.skip(ftype)
17229 
      elif fid == 2:
17230 
        if ftype == TType.I64:
17231 
          self.billingDateFrom = iprot.readI64();
17232 
        else:
17233 
          iprot.skip(ftype)
17234 
      elif fid == 3:
17235 
        if ftype == TType.I64:
17236 
          self.billingDateTo = iprot.readI64();
17237 
        else:
17238 
          iprot.skip(ftype)
17239 
      else:
17240 
        iprot.skip(ftype)
17241 
      iprot.readFieldEnd()
17242 
    iprot.readStructEnd()
17243 
 
17244 
  def write(self, oprot):
17245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17247 
      return
17248 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17249 
    if self.vendorId is not None:
17250 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17251 
      oprot.writeI64(self.vendorId)
17252 
      oprot.writeFieldEnd()
17253 
    if self.billingDateFrom is not None:
17254 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17255 
      oprot.writeI64(self.billingDateFrom)
17256 
      oprot.writeFieldEnd()
17257 
    if self.billingDateTo is not None:
17258 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17259 
      oprot.writeI64(self.billingDateTo)
17260 
      oprot.writeFieldEnd()
17261 
    oprot.writeFieldStop()
17262 
    oprot.writeStructEnd()
17263 
 
17264 
  def validate(self):
17265 
    return
17266 
 
17267 
 
17268 
  def __repr__(self):
17269 
    L = ['%s=%r' % (key, value)
17270 
      for key, value in self.__dict__.iteritems()]
17271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17272 
 
17273 
  def __eq__(self, other):
17274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17275 
 
17276 
  def __ne__(self, other):
17277 
    return not (self == other)
17278 
 
17279 
class getBilledOrdersForVendor_result:
17280 
  """
17281 
  Attributes:
17282 
   - success
17283 
   - ex
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17289 
  )
17290 
 
17291 
  def __init__(self, success=None, ex=None,):
17292 
    self.success = success
17293 
    self.ex = ex
17294 
 
17295 
  def read(self, iprot):
17296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17298 
      return
17299 
    iprot.readStructBegin()
17300 
    while True:
17301 
      (fname, ftype, fid) = iprot.readFieldBegin()
17302 
      if ftype == TType.STOP:
17303 
        break
17304 
      if fid == 0:
17305 
        if ftype == TType.LIST:
17306 
          self.success = []
17307 
          (_etype294, _size291) = iprot.readListBegin()
17308 
          for _i295 in xrange(_size291):
17309 
            _elem296 = Order()
17310 
            _elem296.read(iprot)
17311 
            self.success.append(_elem296)
17312 
          iprot.readListEnd()
17313 
        else:
17314 
          iprot.skip(ftype)
17315 
      elif fid == 1:
17316 
        if ftype == TType.STRUCT:
17317 
          self.ex = TransactionServiceException()
17318 
          self.ex.read(iprot)
17319 
        else:
17320 
          iprot.skip(ftype)
17321 
      else:
17322 
        iprot.skip(ftype)
17323 
      iprot.readFieldEnd()
17324 
    iprot.readStructEnd()
17325 
 
17326 
  def write(self, oprot):
17327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17329 
      return
17330 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17331 
    if self.success is not None:
17332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17334 
      for iter297 in self.success:
17335 
        iter297.write(oprot)
17336 
      oprot.writeListEnd()
17337 
      oprot.writeFieldEnd()
17338 
    if self.ex is not None:
17339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17340 
      self.ex.write(oprot)
17341 
      oprot.writeFieldEnd()
17342 
    oprot.writeFieldStop()
17343 
    oprot.writeStructEnd()
17344 
 
17345 
  def validate(self):
17346 
    return
17347 
 
17348 
 
17349 
  def __repr__(self):
17350 
    L = ['%s=%r' % (key, value)
17351 
      for key, value in self.__dict__.iteritems()]
17352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17353 
 
17354 
  def __eq__(self, other):
17355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17356 
 
17357 
  def __ne__(self, other):
17358 
    return not (self == other)
17359 
 
4607 rajveer 17360 
class getSlippedSippingDateOrders_args:
17361 
 
17362 
  thrift_spec = (
17363 
  )
17364 
 
17365 
  def read(self, iprot):
17366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17368 
      return
17369 
    iprot.readStructBegin()
17370 
    while True:
17371 
      (fname, ftype, fid) = iprot.readFieldBegin()
17372 
      if ftype == TType.STOP:
17373 
        break
17374 
      else:
17375 
        iprot.skip(ftype)
17376 
      iprot.readFieldEnd()
17377 
    iprot.readStructEnd()
17378 
 
17379 
  def write(self, oprot):
17380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17382 
      return
17383 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17384 
    oprot.writeFieldStop()
17385 
    oprot.writeStructEnd()
17386 
 
17387 
  def validate(self):
17388 
    return
17389 
 
17390 
 
17391 
  def __repr__(self):
17392 
    L = ['%s=%r' % (key, value)
17393 
      for key, value in self.__dict__.iteritems()]
17394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17395 
 
17396 
  def __eq__(self, other):
17397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17398 
 
17399 
  def __ne__(self, other):
17400 
    return not (self == other)
17401 
 
17402 
class getSlippedSippingDateOrders_result:
17403 
  """
17404 
  Attributes:
17405 
   - success
17406 
   - ex
17407 
  """
17408 
 
17409 
  thrift_spec = (
17410 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17412 
  )
17413 
 
17414 
  def __init__(self, success=None, ex=None,):
17415 
    self.success = success
17416 
    self.ex = ex
17417 
 
17418 
  def read(self, iprot):
17419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17421 
      return
17422 
    iprot.readStructBegin()
17423 
    while True:
17424 
      (fname, ftype, fid) = iprot.readFieldBegin()
17425 
      if ftype == TType.STOP:
17426 
        break
17427 
      if fid == 0:
17428 
        if ftype == TType.LIST:
17429 
          self.success = []
17430 
          (_etype301, _size298) = iprot.readListBegin()
17431 
          for _i302 in xrange(_size298):
17432 
            _elem303 = Order()
17433 
            _elem303.read(iprot)
17434 
            self.success.append(_elem303)
17435 
          iprot.readListEnd()
17436 
        else:
17437 
          iprot.skip(ftype)
17438 
      elif fid == 1:
17439 
        if ftype == TType.STRUCT:
17440 
          self.ex = TransactionServiceException()
17441 
          self.ex.read(iprot)
17442 
        else:
17443 
          iprot.skip(ftype)
17444 
      else:
17445 
        iprot.skip(ftype)
17446 
      iprot.readFieldEnd()
17447 
    iprot.readStructEnd()
17448 
 
17449 
  def write(self, oprot):
17450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17452 
      return
17453 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17454 
    if self.success is not None:
17455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17456 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17457 
      for iter304 in self.success:
17458 
        iter304.write(oprot)
17459 
      oprot.writeListEnd()
17460 
      oprot.writeFieldEnd()
17461 
    if self.ex is not None:
17462 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17463 
      self.ex.write(oprot)
17464 
      oprot.writeFieldEnd()
17465 
    oprot.writeFieldStop()
17466 
    oprot.writeStructEnd()
17467 
 
17468 
  def validate(self):
17469 
    return
17470 
 
17471 
 
17472 
  def __repr__(self):
17473 
    L = ['%s=%r' % (key, value)
17474 
      for key, value in self.__dict__.iteritems()]
17475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17476 
 
17477 
  def __eq__(self, other):
17478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17479 
 
17480 
  def __ne__(self, other):
17481 
    return not (self == other)
17482 
 
4600 varun.gupt 17483 
class saveBluedartSettlements_args:
17484 
  """
17485 
  Attributes:
17486 
   - mapAWBAndAmount
17487 
  """
17488 
 
17489 
  thrift_spec = (
17490 
    None, # 0
17491 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17492 
  )
17493 
 
17494 
  def __init__(self, mapAWBAndAmount=None,):
17495 
    self.mapAWBAndAmount = mapAWBAndAmount
17496 
 
17497 
  def read(self, iprot):
17498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17500 
      return
17501 
    iprot.readStructBegin()
17502 
    while True:
17503 
      (fname, ftype, fid) = iprot.readFieldBegin()
17504 
      if ftype == TType.STOP:
17505 
        break
17506 
      if fid == 1:
17507 
        if ftype == TType.MAP:
17508 
          self.mapAWBAndAmount = {}
4607 rajveer 17509 
          (_ktype306, _vtype307, _size305 ) = iprot.readMapBegin()
17510 
          for _i309 in xrange(_size305):
17511 
            _key310 = iprot.readI64();
17512 
            _val311 = iprot.readDouble();
17513 
            self.mapAWBAndAmount[_key310] = _val311
4600 varun.gupt 17514 
          iprot.readMapEnd()
17515 
        else:
17516 
          iprot.skip(ftype)
17517 
      else:
17518 
        iprot.skip(ftype)
17519 
      iprot.readFieldEnd()
17520 
    iprot.readStructEnd()
17521 
 
17522 
  def write(self, oprot):
17523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17525 
      return
17526 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17527 
    if self.mapAWBAndAmount is not None:
17528 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17529 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4607 rajveer 17530 
      for kiter312,viter313 in self.mapAWBAndAmount.items():
17531 
        oprot.writeI64(kiter312)
17532 
        oprot.writeDouble(viter313)
4600 varun.gupt 17533 
      oprot.writeMapEnd()
17534 
      oprot.writeFieldEnd()
17535 
    oprot.writeFieldStop()
17536 
    oprot.writeStructEnd()
17537 
 
17538 
  def validate(self):
17539 
    return
17540 
 
17541 
 
17542 
  def __repr__(self):
17543 
    L = ['%s=%r' % (key, value)
17544 
      for key, value in self.__dict__.iteritems()]
17545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17546 
 
17547 
  def __eq__(self, other):
17548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17549 
 
17550 
  def __ne__(self, other):
17551 
    return not (self == other)
17552 
 
17553 
class saveBluedartSettlements_result:
17554 
  """
17555 
  Attributes:
17556 
   - ex
17557 
  """
17558 
 
17559 
  thrift_spec = (
17560 
    None, # 0
17561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17562 
  )
17563 
 
17564 
  def __init__(self, ex=None,):
17565 
    self.ex = ex
17566 
 
17567 
  def read(self, iprot):
17568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17570 
      return
17571 
    iprot.readStructBegin()
17572 
    while True:
17573 
      (fname, ftype, fid) = iprot.readFieldBegin()
17574 
      if ftype == TType.STOP:
17575 
        break
17576 
      if fid == 1:
17577 
        if ftype == TType.STRUCT:
17578 
          self.ex = TransactionServiceException()
17579 
          self.ex.read(iprot)
17580 
        else:
17581 
          iprot.skip(ftype)
17582 
      else:
17583 
        iprot.skip(ftype)
17584 
      iprot.readFieldEnd()
17585 
    iprot.readStructEnd()
17586 
 
17587 
  def write(self, oprot):
17588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17590 
      return
17591 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17592 
    if self.ex is not None:
17593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17594 
      self.ex.write(oprot)
17595 
      oprot.writeFieldEnd()
17596 
    oprot.writeFieldStop()
17597 
    oprot.writeStructEnd()
17598 
 
17599 
  def validate(self):
17600 
    return
17601 
 
17602 
 
17603 
  def __repr__(self):
17604 
    L = ['%s=%r' % (key, value)
17605 
      for key, value in self.__dict__.iteritems()]
17606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17607 
 
17608 
  def __eq__(self, other):
17609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17610 
 
17611 
  def __ne__(self, other):
17612 
    return not (self == other)
17613 
 
17614 
class savePaymentSettlements_args:
17615 
  """
17616 
  Attributes:
17617 
   - settlementDate
17618 
   - paymentGatewayId
17619 
   - paymentId
17620 
   - serviceTax
17621 
   - otherCharges
17622 
   - netCollection
17623 
  """
17624 
 
17625 
  thrift_spec = (
17626 
    None, # 0
17627 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17628 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17629 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17630 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17631 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17632 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17633 
  )
17634 
 
17635 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17636 
    self.settlementDate = settlementDate
17637 
    self.paymentGatewayId = paymentGatewayId
17638 
    self.paymentId = paymentId
17639 
    self.serviceTax = serviceTax
17640 
    self.otherCharges = otherCharges
17641 
    self.netCollection = netCollection
17642 
 
17643 
  def read(self, iprot):
17644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17646 
      return
17647 
    iprot.readStructBegin()
17648 
    while True:
17649 
      (fname, ftype, fid) = iprot.readFieldBegin()
17650 
      if ftype == TType.STOP:
17651 
        break
17652 
      if fid == 1:
17653 
        if ftype == TType.I64:
17654 
          self.settlementDate = iprot.readI64();
17655 
        else:
17656 
          iprot.skip(ftype)
17657 
      elif fid == 2:
17658 
        if ftype == TType.I64:
17659 
          self.paymentGatewayId = iprot.readI64();
17660 
        else:
17661 
          iprot.skip(ftype)
17662 
      elif fid == 3:
17663 
        if ftype == TType.I64:
17664 
          self.paymentId = iprot.readI64();
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      elif fid == 4:
17668 
        if ftype == TType.DOUBLE:
17669 
          self.serviceTax = iprot.readDouble();
17670 
        else:
17671 
          iprot.skip(ftype)
17672 
      elif fid == 5:
17673 
        if ftype == TType.DOUBLE:
17674 
          self.otherCharges = iprot.readDouble();
17675 
        else:
17676 
          iprot.skip(ftype)
17677 
      elif fid == 6:
17678 
        if ftype == TType.DOUBLE:
17679 
          self.netCollection = iprot.readDouble();
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      else:
17683 
        iprot.skip(ftype)
17684 
      iprot.readFieldEnd()
17685 
    iprot.readStructEnd()
17686 
 
17687 
  def write(self, oprot):
17688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17690 
      return
17691 
    oprot.writeStructBegin('savePaymentSettlements_args')
17692 
    if self.settlementDate is not None:
17693 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17694 
      oprot.writeI64(self.settlementDate)
17695 
      oprot.writeFieldEnd()
17696 
    if self.paymentGatewayId is not None:
17697 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17698 
      oprot.writeI64(self.paymentGatewayId)
17699 
      oprot.writeFieldEnd()
17700 
    if self.paymentId is not None:
17701 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17702 
      oprot.writeI64(self.paymentId)
17703 
      oprot.writeFieldEnd()
17704 
    if self.serviceTax is not None:
17705 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17706 
      oprot.writeDouble(self.serviceTax)
17707 
      oprot.writeFieldEnd()
17708 
    if self.otherCharges is not None:
17709 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17710 
      oprot.writeDouble(self.otherCharges)
17711 
      oprot.writeFieldEnd()
17712 
    if self.netCollection is not None:
17713 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17714 
      oprot.writeDouble(self.netCollection)
17715 
      oprot.writeFieldEnd()
17716 
    oprot.writeFieldStop()
17717 
    oprot.writeStructEnd()
17718 
 
17719 
  def validate(self):
17720 
    return
17721 
 
17722 
 
17723 
  def __repr__(self):
17724 
    L = ['%s=%r' % (key, value)
17725 
      for key, value in self.__dict__.iteritems()]
17726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17727 
 
17728 
  def __eq__(self, other):
17729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17730 
 
17731 
  def __ne__(self, other):
17732 
    return not (self == other)
17733 
 
17734 
class savePaymentSettlements_result:
17735 
  """
17736 
  Attributes:
17737 
   - ex
17738 
  """
17739 
 
17740 
  thrift_spec = (
17741 
    None, # 0
17742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17743 
  )
17744 
 
17745 
  def __init__(self, ex=None,):
17746 
    self.ex = ex
17747 
 
17748 
  def read(self, iprot):
17749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17751 
      return
17752 
    iprot.readStructBegin()
17753 
    while True:
17754 
      (fname, ftype, fid) = iprot.readFieldBegin()
17755 
      if ftype == TType.STOP:
17756 
        break
17757 
      if fid == 1:
17758 
        if ftype == TType.STRUCT:
17759 
          self.ex = TransactionServiceException()
17760 
          self.ex.read(iprot)
17761 
        else:
17762 
          iprot.skip(ftype)
17763 
      else:
17764 
        iprot.skip(ftype)
17765 
      iprot.readFieldEnd()
17766 
    iprot.readStructEnd()
17767 
 
17768 
  def write(self, oprot):
17769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17771 
      return
17772 
    oprot.writeStructBegin('savePaymentSettlements_result')
17773 
    if self.ex is not None:
17774 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17775 
      self.ex.write(oprot)
17776 
      oprot.writeFieldEnd()
17777 
    oprot.writeFieldStop()
17778 
    oprot.writeStructEnd()
17779 
 
17780 
  def validate(self):
17781 
    return
17782 
 
17783 
 
17784 
  def __repr__(self):
17785 
    L = ['%s=%r' % (key, value)
17786 
      for key, value in self.__dict__.iteritems()]
17787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17788 
 
17789 
  def __eq__(self, other):
17790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17791 
 
17792 
  def __ne__(self, other):
17793 
    return not (self == other)
17794 
 
17795 
class saveEBSSettlementSummary_args:
17796 
  """
17797 
  Attributes:
17798 
   - settlementId
17799 
   - settlementDate
17800 
   - transactionDateFrom
17801 
   - transactionDateTo
17802 
   - amount
17803 
  """
17804 
 
17805 
  thrift_spec = (
17806 
    None, # 0
17807 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17808 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
17809 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
17810 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
17811 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
17812 
  )
17813 
 
17814 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
17815 
    self.settlementId = settlementId
17816 
    self.settlementDate = settlementDate
17817 
    self.transactionDateFrom = transactionDateFrom
17818 
    self.transactionDateTo = transactionDateTo
17819 
    self.amount = amount
17820 
 
17821 
  def read(self, iprot):
17822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17824 
      return
17825 
    iprot.readStructBegin()
17826 
    while True:
17827 
      (fname, ftype, fid) = iprot.readFieldBegin()
17828 
      if ftype == TType.STOP:
17829 
        break
17830 
      if fid == 1:
17831 
        if ftype == TType.I64:
17832 
          self.settlementId = iprot.readI64();
17833 
        else:
17834 
          iprot.skip(ftype)
17835 
      elif fid == 2:
17836 
        if ftype == TType.I64:
17837 
          self.settlementDate = iprot.readI64();
17838 
        else:
17839 
          iprot.skip(ftype)
17840 
      elif fid == 3:
17841 
        if ftype == TType.I64:
17842 
          self.transactionDateFrom = iprot.readI64();
17843 
        else:
17844 
          iprot.skip(ftype)
17845 
      elif fid == 4:
17846 
        if ftype == TType.I64:
17847 
          self.transactionDateTo = iprot.readI64();
17848 
        else:
17849 
          iprot.skip(ftype)
17850 
      elif fid == 5:
17851 
        if ftype == TType.DOUBLE:
17852 
          self.amount = iprot.readDouble();
17853 
        else:
17854 
          iprot.skip(ftype)
17855 
      else:
17856 
        iprot.skip(ftype)
17857 
      iprot.readFieldEnd()
17858 
    iprot.readStructEnd()
17859 
 
17860 
  def write(self, oprot):
17861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17863 
      return
17864 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
17865 
    if self.settlementId is not None:
17866 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17867 
      oprot.writeI64(self.settlementId)
17868 
      oprot.writeFieldEnd()
17869 
    if self.settlementDate is not None:
17870 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
17871 
      oprot.writeI64(self.settlementDate)
17872 
      oprot.writeFieldEnd()
17873 
    if self.transactionDateFrom is not None:
17874 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
17875 
      oprot.writeI64(self.transactionDateFrom)
17876 
      oprot.writeFieldEnd()
17877 
    if self.transactionDateTo is not None:
17878 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
17879 
      oprot.writeI64(self.transactionDateTo)
17880 
      oprot.writeFieldEnd()
17881 
    if self.amount is not None:
17882 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
17883 
      oprot.writeDouble(self.amount)
17884 
      oprot.writeFieldEnd()
17885 
    oprot.writeFieldStop()
17886 
    oprot.writeStructEnd()
17887 
 
17888 
  def validate(self):
17889 
    return
17890 
 
17891 
 
17892 
  def __repr__(self):
17893 
    L = ['%s=%r' % (key, value)
17894 
      for key, value in self.__dict__.iteritems()]
17895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17896 
 
17897 
  def __eq__(self, other):
17898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17899 
 
17900 
  def __ne__(self, other):
17901 
    return not (self == other)
17902 
 
17903 
class saveEBSSettlementSummary_result:
17904 
  """
17905 
  Attributes:
17906 
   - ex
17907 
  """
17908 
 
17909 
  thrift_spec = (
17910 
    None, # 0
17911 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17912 
  )
17913 
 
17914 
  def __init__(self, ex=None,):
17915 
    self.ex = ex
17916 
 
17917 
  def read(self, iprot):
17918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17920 
      return
17921 
    iprot.readStructBegin()
17922 
    while True:
17923 
      (fname, ftype, fid) = iprot.readFieldBegin()
17924 
      if ftype == TType.STOP:
17925 
        break
17926 
      if fid == 1:
17927 
        if ftype == TType.STRUCT:
17928 
          self.ex = TransactionServiceException()
17929 
          self.ex.read(iprot)
17930 
        else:
17931 
          iprot.skip(ftype)
17932 
      else:
17933 
        iprot.skip(ftype)
17934 
      iprot.readFieldEnd()
17935 
    iprot.readStructEnd()
17936 
 
17937 
  def write(self, oprot):
17938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17940 
      return
17941 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
17942 
    if self.ex is not None:
17943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17944 
      self.ex.write(oprot)
17945 
      oprot.writeFieldEnd()
17946 
    oprot.writeFieldStop()
17947 
    oprot.writeStructEnd()
17948 
 
17949 
  def validate(self):
17950 
    return
17951 
 
17952 
 
17953 
  def __repr__(self):
17954 
    L = ['%s=%r' % (key, value)
17955 
      for key, value in self.__dict__.iteritems()]
17956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17957 
 
17958 
  def __eq__(self, other):
17959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17960 
 
17961 
  def __ne__(self, other):
17962 
    return not (self == other)
17963 
 
17964 
class getSettlementForPaymentId_args:
17965 
  """
17966 
  Attributes:
17967 
   - paymentId
17968 
  """
17969 
 
17970 
  thrift_spec = (
17971 
    None, # 0
17972 
    (1, TType.I64, 'paymentId', None, None, ), # 1
17973 
  )
17974 
 
17975 
  def __init__(self, paymentId=None,):
17976 
    self.paymentId = paymentId
17977 
 
17978 
  def read(self, iprot):
17979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17981 
      return
17982 
    iprot.readStructBegin()
17983 
    while True:
17984 
      (fname, ftype, fid) = iprot.readFieldBegin()
17985 
      if ftype == TType.STOP:
17986 
        break
17987 
      if fid == 1:
17988 
        if ftype == TType.I64:
17989 
          self.paymentId = iprot.readI64();
17990 
        else:
17991 
          iprot.skip(ftype)
17992 
      else:
17993 
        iprot.skip(ftype)
17994 
      iprot.readFieldEnd()
17995 
    iprot.readStructEnd()
17996 
 
17997 
  def write(self, oprot):
17998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18000 
      return
18001 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18002 
    if self.paymentId is not None:
18003 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18004 
      oprot.writeI64(self.paymentId)
18005 
      oprot.writeFieldEnd()
18006 
    oprot.writeFieldStop()
18007 
    oprot.writeStructEnd()
18008 
 
18009 
  def validate(self):
18010 
    return
18011 
 
18012 
 
18013 
  def __repr__(self):
18014 
    L = ['%s=%r' % (key, value)
18015 
      for key, value in self.__dict__.iteritems()]
18016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18017 
 
18018 
  def __eq__(self, other):
18019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18020 
 
18021 
  def __ne__(self, other):
18022 
    return not (self == other)
18023 
 
18024 
class getSettlementForPaymentId_result:
18025 
  """
18026 
  Attributes:
18027 
   - success
18028 
   - ex
18029 
  """
18030 
 
18031 
  thrift_spec = (
18032 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18034 
  )
18035 
 
18036 
  def __init__(self, success=None, ex=None,):
18037 
    self.success = success
18038 
    self.ex = ex
18039 
 
18040 
  def read(self, iprot):
18041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18043 
      return
18044 
    iprot.readStructBegin()
18045 
    while True:
18046 
      (fname, ftype, fid) = iprot.readFieldBegin()
18047 
      if ftype == TType.STOP:
18048 
        break
18049 
      if fid == 0:
18050 
        if ftype == TType.STRUCT:
18051 
          self.success = PaymentSettlement()
18052 
          self.success.read(iprot)
18053 
        else:
18054 
          iprot.skip(ftype)
18055 
      elif fid == 1:
18056 
        if ftype == TType.STRUCT:
18057 
          self.ex = TransactionServiceException()
18058 
          self.ex.read(iprot)
18059 
        else:
18060 
          iprot.skip(ftype)
18061 
      else:
18062 
        iprot.skip(ftype)
18063 
      iprot.readFieldEnd()
18064 
    iprot.readStructEnd()
18065 
 
18066 
  def write(self, oprot):
18067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18069 
      return
18070 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18071 
    if self.success is not None:
18072 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18073 
      self.success.write(oprot)
18074 
      oprot.writeFieldEnd()
18075 
    if self.ex is not None:
18076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18077 
      self.ex.write(oprot)
18078 
      oprot.writeFieldEnd()
18079 
    oprot.writeFieldStop()
18080 
    oprot.writeStructEnd()
18081 
 
18082 
  def validate(self):
18083 
    return
18084 
 
18085 
 
18086 
  def __repr__(self):
18087 
    L = ['%s=%r' % (key, value)
18088 
      for key, value in self.__dict__.iteritems()]
18089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18090 
 
18091 
  def __eq__(self, other):
18092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18093 
 
18094 
  def __ne__(self, other):
18095 
    return not (self == other)
18096 
 
18097 
class getEBSSettlementSummaries_args:
18098 
 
18099 
  thrift_spec = (
18100 
  )
18101 
 
18102 
  def read(self, iprot):
18103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18105 
      return
18106 
    iprot.readStructBegin()
18107 
    while True:
18108 
      (fname, ftype, fid) = iprot.readFieldBegin()
18109 
      if ftype == TType.STOP:
18110 
        break
18111 
      else:
18112 
        iprot.skip(ftype)
18113 
      iprot.readFieldEnd()
18114 
    iprot.readStructEnd()
18115 
 
18116 
  def write(self, oprot):
18117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18119 
      return
18120 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18121 
    oprot.writeFieldStop()
18122 
    oprot.writeStructEnd()
18123 
 
18124 
  def validate(self):
18125 
    return
18126 
 
18127 
 
18128 
  def __repr__(self):
18129 
    L = ['%s=%r' % (key, value)
18130 
      for key, value in self.__dict__.iteritems()]
18131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18132 
 
18133 
  def __eq__(self, other):
18134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18135 
 
18136 
  def __ne__(self, other):
18137 
    return not (self == other)
18138 
 
18139 
class getEBSSettlementSummaries_result:
18140 
  """
18141 
  Attributes:
18142 
   - success
18143 
   - ex
18144 
  """
18145 
 
18146 
  thrift_spec = (
18147 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18149 
  )
18150 
 
18151 
  def __init__(self, success=None, ex=None,):
18152 
    self.success = success
18153 
    self.ex = ex
18154 
 
18155 
  def read(self, iprot):
18156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18158 
      return
18159 
    iprot.readStructBegin()
18160 
    while True:
18161 
      (fname, ftype, fid) = iprot.readFieldBegin()
18162 
      if ftype == TType.STOP:
18163 
        break
18164 
      if fid == 0:
18165 
        if ftype == TType.MAP:
18166 
          self.success = {}
4607 rajveer 18167 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
18168 
          for _i318 in xrange(_size314):
18169 
            _key319 = iprot.readI64();
18170 
            _val320 = iprot.readString();
18171 
            self.success[_key319] = _val320
4600 varun.gupt 18172 
          iprot.readMapEnd()
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      elif fid == 1:
18176 
        if ftype == TType.STRUCT:
18177 
          self.ex = TransactionServiceException()
18178 
          self.ex.read(iprot)
18179 
        else:
18180 
          iprot.skip(ftype)
18181 
      else:
18182 
        iprot.skip(ftype)
18183 
      iprot.readFieldEnd()
18184 
    iprot.readStructEnd()
18185 
 
18186 
  def write(self, oprot):
18187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18189 
      return
18190 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18191 
    if self.success is not None:
18192 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18193 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4607 rajveer 18194 
      for kiter321,viter322 in self.success.items():
18195 
        oprot.writeI64(kiter321)
18196 
        oprot.writeString(viter322)
4600 varun.gupt 18197 
      oprot.writeMapEnd()
18198 
      oprot.writeFieldEnd()
18199 
    if self.ex is not None:
18200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18201 
      self.ex.write(oprot)
18202 
      oprot.writeFieldEnd()
18203 
    oprot.writeFieldStop()
18204 
    oprot.writeStructEnd()
18205 
 
18206 
  def validate(self):
18207 
    return
18208 
 
18209 
 
18210 
  def __repr__(self):
18211 
    L = ['%s=%r' % (key, value)
18212 
      for key, value in self.__dict__.iteritems()]
18213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18214 
 
18215 
  def __eq__(self, other):
18216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18217 
 
18218 
  def __ne__(self, other):
18219 
    return not (self == other)
18220 
 
18221 
class markEBSSettlementUploaded_args:
18222 
  """
18223 
  Attributes:
18224 
   - settlementId
18225 
  """
18226 
 
18227 
  thrift_spec = (
18228 
    None, # 0
18229 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18230 
  )
18231 
 
18232 
  def __init__(self, settlementId=None,):
18233 
    self.settlementId = settlementId
18234 
 
18235 
  def read(self, iprot):
18236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18238 
      return
18239 
    iprot.readStructBegin()
18240 
    while True:
18241 
      (fname, ftype, fid) = iprot.readFieldBegin()
18242 
      if ftype == TType.STOP:
18243 
        break
18244 
      if fid == 1:
18245 
        if ftype == TType.I64:
18246 
          self.settlementId = iprot.readI64();
18247 
        else:
18248 
          iprot.skip(ftype)
18249 
      else:
18250 
        iprot.skip(ftype)
18251 
      iprot.readFieldEnd()
18252 
    iprot.readStructEnd()
18253 
 
18254 
  def write(self, oprot):
18255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18257 
      return
18258 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18259 
    if self.settlementId is not None:
18260 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18261 
      oprot.writeI64(self.settlementId)
18262 
      oprot.writeFieldEnd()
18263 
    oprot.writeFieldStop()
18264 
    oprot.writeStructEnd()
18265 
 
18266 
  def validate(self):
18267 
    return
18268 
 
18269 
 
18270 
  def __repr__(self):
18271 
    L = ['%s=%r' % (key, value)
18272 
      for key, value in self.__dict__.iteritems()]
18273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18274 
 
18275 
  def __eq__(self, other):
18276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18277 
 
18278 
  def __ne__(self, other):
18279 
    return not (self == other)
18280 
 
18281 
class markEBSSettlementUploaded_result:
18282 
  """
18283 
  Attributes:
18284 
   - ex
18285 
  """
18286 
 
18287 
  thrift_spec = (
18288 
    None, # 0
18289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18290 
  )
18291 
 
18292 
  def __init__(self, ex=None,):
18293 
    self.ex = ex
18294 
 
18295 
  def read(self, iprot):
18296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18298 
      return
18299 
    iprot.readStructBegin()
18300 
    while True:
18301 
      (fname, ftype, fid) = iprot.readFieldBegin()
18302 
      if ftype == TType.STOP:
18303 
        break
18304 
      if fid == 1:
18305 
        if ftype == TType.STRUCT:
18306 
          self.ex = TransactionServiceException()
18307 
          self.ex.read(iprot)
18308 
        else:
18309 
          iprot.skip(ftype)
18310 
      else:
18311 
        iprot.skip(ftype)
18312 
      iprot.readFieldEnd()
18313 
    iprot.readStructEnd()
18314 
 
18315 
  def write(self, oprot):
18316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18318 
      return
18319 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18320 
    if self.ex is not None:
18321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18322 
      self.ex.write(oprot)
18323 
      oprot.writeFieldEnd()
18324 
    oprot.writeFieldStop()
18325 
    oprot.writeStructEnd()
18326 
 
18327 
  def validate(self):
18328 
    return
18329 
 
18330 
 
18331 
  def __repr__(self):
18332 
    L = ['%s=%r' % (key, value)
18333 
      for key, value in self.__dict__.iteritems()]
18334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18335 
 
18336 
  def __eq__(self, other):
18337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18338 
 
18339 
  def __ne__(self, other):
18340 
    return not (self == other)
18341 
 
18342 
class getEBSSettlementDate_args:
18343 
  """
18344 
  Attributes:
18345 
   - settlementId
18346 
  """
18347 
 
18348 
  thrift_spec = (
18349 
    None, # 0
18350 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18351 
  )
18352 
 
18353 
  def __init__(self, settlementId=None,):
18354 
    self.settlementId = settlementId
18355 
 
18356 
  def read(self, iprot):
18357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18359 
      return
18360 
    iprot.readStructBegin()
18361 
    while True:
18362 
      (fname, ftype, fid) = iprot.readFieldBegin()
18363 
      if ftype == TType.STOP:
18364 
        break
18365 
      if fid == 1:
18366 
        if ftype == TType.I64:
18367 
          self.settlementId = iprot.readI64();
18368 
        else:
18369 
          iprot.skip(ftype)
18370 
      else:
18371 
        iprot.skip(ftype)
18372 
      iprot.readFieldEnd()
18373 
    iprot.readStructEnd()
18374 
 
18375 
  def write(self, oprot):
18376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18378 
      return
18379 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18380 
    if self.settlementId is not None:
18381 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18382 
      oprot.writeI64(self.settlementId)
18383 
      oprot.writeFieldEnd()
18384 
    oprot.writeFieldStop()
18385 
    oprot.writeStructEnd()
18386 
 
18387 
  def validate(self):
18388 
    return
18389 
 
18390 
 
18391 
  def __repr__(self):
18392 
    L = ['%s=%r' % (key, value)
18393 
      for key, value in self.__dict__.iteritems()]
18394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18395 
 
18396 
  def __eq__(self, other):
18397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18398 
 
18399 
  def __ne__(self, other):
18400 
    return not (self == other)
18401 
 
18402 
class getEBSSettlementDate_result:
18403 
  """
18404 
  Attributes:
18405 
   - success
18406 
   - ex
18407 
  """
18408 
 
18409 
  thrift_spec = (
18410 
    (0, TType.I64, 'success', None, None, ), # 0
18411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18412 
  )
18413 
 
18414 
  def __init__(self, success=None, ex=None,):
18415 
    self.success = success
18416 
    self.ex = ex
18417 
 
18418 
  def read(self, iprot):
18419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18421 
      return
18422 
    iprot.readStructBegin()
18423 
    while True:
18424 
      (fname, ftype, fid) = iprot.readFieldBegin()
18425 
      if ftype == TType.STOP:
18426 
        break
18427 
      if fid == 0:
18428 
        if ftype == TType.I64:
18429 
          self.success = iprot.readI64();
18430 
        else:
18431 
          iprot.skip(ftype)
18432 
      elif fid == 1:
18433 
        if ftype == TType.STRUCT:
18434 
          self.ex = TransactionServiceException()
18435 
          self.ex.read(iprot)
18436 
        else:
18437 
          iprot.skip(ftype)
18438 
      else:
18439 
        iprot.skip(ftype)
18440 
      iprot.readFieldEnd()
18441 
    iprot.readStructEnd()
18442 
 
18443 
  def write(self, oprot):
18444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18446 
      return
18447 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18448 
    if self.success is not None:
18449 
      oprot.writeFieldBegin('success', TType.I64, 0)
18450 
      oprot.writeI64(self.success)
18451 
      oprot.writeFieldEnd()
18452 
    if self.ex is not None:
18453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18454 
      self.ex.write(oprot)
18455 
      oprot.writeFieldEnd()
18456 
    oprot.writeFieldStop()
18457 
    oprot.writeStructEnd()
18458 
 
18459 
  def validate(self):
18460 
    return
18461 
 
18462 
 
18463 
  def __repr__(self):
18464 
    L = ['%s=%r' % (key, value)
18465 
      for key, value in self.__dict__.iteritems()]
18466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18467 
 
18468 
  def __eq__(self, other):
18469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18470 
 
18471 
  def __ne__(self, other):
18472 
    return not (self == other)