Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
3064 chandransh 330 
     - imeiNumber
331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
435 
    Returns the final flag status.
436 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4454 rajveer 443 
  def markOrderDoaRequestReceived(self, orderId):
444 
    """
445 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
446 
 
447 
    Parameters:
448 
     - orderId
449 
    """
450 
    pass
451 
 
452 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
453 
    """
454 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
455 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
456 
 
457 
    Parameters:
458 
     - orderId
459 
     - isAuthorized
460 
    """
461 
    pass
462 
 
4488 rajveer 463 
  def markOrderReturnRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
475 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4579 rajveer 483 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 484 
    """
485 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 486 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
487 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 488 
    For any other status, it returns false.
489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2536 chandransh 491 
    Parameters:
492 
     - orderId
4579 rajveer 493 
     - providerId
2536 chandransh 494 
    """
495 
    pass
496 
 
4602 rajveer 497 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 498 
    """
4452 rajveer 499 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 500 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
501 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
502 
    	3. Returns true
2591 chandransh 503 
    If the order is in any other status, it returns false.
2536 chandransh 504 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 505 
 
2536 chandransh 506 
    Parameters:
507 
     - orderId
508 
     - pickupNumber
4602 rajveer 509 
     - providerId
2536 chandransh 510 
    """
511 
    pass
512 
 
2764 chandransh 513 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
514 
    """
515 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
516 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 517 
 
2764 chandransh 518 
    Parameters:
519 
     - providerId
520 
     - pickupDetails
521 
    """
522 
    pass
523 
 
4479 rajveer 524 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 525 
    """
4452 rajveer 526 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 527 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 528 
    If the order is in any other state, it returns false.
529 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 530 
 
2591 chandransh 531 
    Parameters:
532 
     - orderId
4479 rajveer 533 
     - receiveCondition
2591 chandransh 534 
    """
535 
    pass
2536 chandransh 536 
 
2591 chandransh 537 
  def validateDoa(self, orderId, isValid):
538 
    """
4452 rajveer 539 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 540 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 541 
    If the order is in any other state, it returns false.
542 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 543 
 
2591 chandransh 544 
    Parameters:
545 
     - orderId
546 
     - isValid
547 
    """
548 
    pass
549 
 
4495 rajveer 550 
  def validateReturnProduct(self, orderId, isUsable):
551 
    """
552 
    Parameters:
553 
     - orderId
554 
     - isUsable
555 
    """
556 
    pass
557 
 
2616 chandransh 558 
  def reshipOrder(self, orderId):
559 
    """
4484 rajveer 560 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 561 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 562 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 563 
 
564 
    If the order is in DOA_CERT_VALID state, it does the following:
565 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
566 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 567 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 568 
 
2616 chandransh 569 
    Returns the id of the newly created order.
3431 rajveer 570 
 
2616 chandransh 571 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 572 
 
2616 chandransh 573 
    Parameters:
574 
     - orderId
575 
    """
576 
    pass
2591 chandransh 577 
 
3226 chandransh 578 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 579 
    """
4484 rajveer 580 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 581 
    	1. Creates a refund request for batch processing.
582 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 583 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 584 
 
2616 chandransh 585 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
586 
    	1. Creates a refund request for batch processing.
3226 chandransh 587 
    	2. Cancels the reservation of the item in the warehouse.
588 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 589 
 
3226 chandransh 590 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
591 
    	1. Cancels the reservation of the item in the warehouse.
592 
    	2. Marks the current order as CANCELED.
593 
 
594 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
595 
 
2616 chandransh 596 
    Returns True if it is successful, False otherwise.
3431 rajveer 597 
 
2616 chandransh 598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2616 chandransh 600 
    Parameters:
601 
     - orderId
3226 chandransh 602 
     - refundedBy
603 
     - reason
2616 chandransh 604 
    """
605 
    pass
606 
 
2690 chandransh 607 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
608 
    """
609 
    Get all return orders created between the from and to dates for the given warehouse.
610 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 611 
 
2690 chandransh 612 
    Parameters:
613 
     - warehouseId
614 
     - fromDate
615 
     - toDate
616 
    """
617 
    pass
2616 chandransh 618 
 
2700 chandransh 619 
  def getReturnOrder(self, id):
620 
    """
621 
    Returns the ReturnOrder corresponding to the given id.
622 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 623 
 
2700 chandransh 624 
    Parameters:
625 
     - id
626 
    """
627 
    pass
628 
 
2690 chandransh 629 
  def processReturn(self, returnOrderId):
630 
    """
631 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 632 
 
2690 chandransh 633 
    Parameters:
634 
     - returnOrderId
635 
    """
636 
    pass
637 
 
2819 chandransh 638 
  def createPurchaseOrder(self, warehouseId):
639 
    """
4586 mandeep.dh 640 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
641 
    Returns the list of PO no. of the newly created purchase order.
642 
    Returns null if no new purchase order had to be created.
3431 rajveer 643 
 
2819 chandransh 644 
    Parameters:
645 
     - warehouseId
646 
    """
647 
    pass
2690 chandransh 648 
 
3451 chandransh 649 
  def updateWeight(self, orderId, weight):
650 
    """
651 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 652 
 
3451 chandransh 653 
    Parameters:
654 
     - orderId
655 
     - weight
656 
    """
657 
    pass
658 
 
3469 chandransh 659 
  def changeItem(self, orderId, itemId):
660 
    """
661 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
662 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 663 
 
3469 chandransh 664 
    Parameters:
665 
     - orderId
666 
     - itemId
667 
    """
668 
    pass
669 
 
670 
  def shiftToWarehouse(self, orderId, warehouseId):
671 
    """
672 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
673 
 
674 
    Parameters:
675 
     - orderId
676 
     - warehouseId
677 
    """
678 
    pass
679 
 
3986 chandransh 680 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
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
3553 chandransh 690 
    """
691 
    pass
692 
 
3956 chandransh 693 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
694 
    """
695 
    Marks the COD orders with given AWB nos. as having been processed.
696 
    Updates the captured amount for the corresponding payment.
3553 chandransh 697 
 
3956 chandransh 698 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
699 
    1. There is no order corresponding to an AWB number.
700 
    2. The captured amount for a payment exceeds the total payment.
701 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
702 
 
703 
    Parameters:
704 
     - collectedAmountMap
705 
     - xferBy
706 
     - xferTxnId
707 
     - xferDate
708 
    """
709 
    pass
710 
 
4008 mandeep.dh 711 
  def getTransactionsRequiringExtraProcessing(self, category):
712 
    """
4065 mandeep.dh 713 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 714 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 715 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 716 
 
4008 mandeep.dh 717 
    Parameters:
718 
     - category
719 
    """
720 
    pass
721 
 
722 
  def markTransactionAsProcessed(self, transactionId, category):
723 
    """
724 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 725 
    It essentially deletes the transaction id record for a particular
726 
    processing type category (if present) from DB.
727 
    This is currently used by CRM application.
4008 mandeep.dh 728 
 
729 
    Parameters:
730 
     - transactionId
731 
     - category
732 
    """
733 
    pass
734 
 
4018 chandransh 735 
  def getItemWiseRiskyOrdersCount(self, ):
736 
    """
737 
    Returns a map containing the number of risky orders keyed by item id. A risky order
738 
    is defined as one whose shipping date is about to expire.
739 
    """
740 
    pass
4008 mandeep.dh 741 
 
4295 varun.gupt 742 
  def getOrdersForItemIds(self, itemIds):
743 
    """
744 
    Returns a list of all orders which have items with given id
745 
 
746 
    Parameters:
747 
     - itemIds
748 
    """
749 
    pass
750 
 
4247 rajveer 751 
  def markOrderCancellationRequestReceived(self, orderId):
752 
    """
753 
    Mark order as cancellation request received. If customer sends request of cancellation of
754 
    a particular order, this method will be called. It will just change status of the order
755 
    depending on its current status. It also records the previous status, so that we can move
756 
    back to that status if cancellation request is denied.
4018 chandransh 757 
 
4247 rajveer 758 
    Parameters:
759 
     - orderId
760 
    """
761 
    pass
762 
 
763 
  def markOrderCancellationRequestConfirmed(self, orderId):
764 
    """
765 
    If we decide to to cancel order, CRM will call this method to move the status of order to
766 
    cancellation request confirmed. After this OM will be able to cancel the order.
767 
 
768 
    Parameters:
769 
     - orderId
770 
    """
771 
    pass
772 
 
773 
  def markOrderCancellationRequestDenied(self, orderId):
774 
    """
775 
    If we decide to not to cancel order, we will move the order ro previous status.
776 
 
777 
    Parameters:
778 
     - orderId
779 
    """
780 
    pass
781 
 
4258 rajveer 782 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 783 
    """
4258 rajveer 784 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
785 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 786 
 
787 
    Parameters:
4258 rajveer 788 
     - transactionId
4247 rajveer 789 
    """
790 
    pass
791 
 
4259 anupam.sin 792 
  def refundTransaction(self, transactionId, refundedBy, reason):
793 
    """
794 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
795 
    need to be cancelled
4247 rajveer 796 
 
4259 anupam.sin 797 
    Parameters:
798 
     - transactionId
799 
     - refundedBy
800 
     - reason
801 
    """
802 
    pass
803 
 
4324 mandeep.dh 804 
  def updateShipmentAddress(self, orderId, addressId):
805 
    """
806 
    Updates shipment address of an order. Delivery and shipping date estimates
807 
    etc. are also updated here.
808 
 
809 
    Throws TransactionServiceException in case address change is not
810 
    possible due to certain reasons such as new pincode in address is
811 
    not serviceable etc.
812 
 
813 
    Parameters:
814 
     - orderId
815 
     - addressId
816 
    """
817 
    pass
818 
 
4285 rajveer 819 
  def acceptOrdersForItemId(self, itemId, inventory):
820 
    """
821 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
822 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 823 
 
4285 rajveer 824 
    Parameters:
825 
     - itemId
826 
     - inventory
827 
    """
828 
    pass
829 
 
4369 rajveer 830 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 831 
    """
832 
    Parameters:
833 
     - vendorId
834 
     - itemId
835 
     - quantity
836 
     - estimate
4369 rajveer 837 
     - isReminder
4303 rajveer 838 
    """
839 
    pass
4285 rajveer 840 
 
4369 rajveer 841 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 842 
    """
843 
    Parameters:
844 
     - vendorId
845 
     - itemId
846 
     - quantity
847 
     - estimate
4369 rajveer 848 
     - isReminder
4303 rajveer 849 
    """
850 
    pass
851 
 
4369 rajveer 852 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 853 
    """
854 
    Parameters:
855 
     - vendorId
856 
     - itemId
857 
     - quantity
858 
     - estimate
4369 rajveer 859 
     - isReminder
4303 rajveer 860 
    """
861 
    pass
862 
 
4369 rajveer 863 
  def markOrdersAsTimeout(self, vendorId):
864 
    """
865 
    Parameters:
866 
     - vendorId
867 
    """
868 
    pass
4303 rajveer 869 
 
4386 anupam.sin 870 
  def getOrderForAwb(self, awb):
871 
    """
872 
    Returns the order corresponding to an AWB number
4369 rajveer 873 
 
4386 anupam.sin 874 
    Parameters:
875 
     - awb
876 
    """
877 
    pass
878 
 
4506 phani.kuma 879 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
880 
    """
881 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 882 
 
4506 phani.kuma 883 
    Parameters:
884 
     - logistics_provider_id
885 
     - order_status
886 
    """
887 
    pass
888 
 
4600 varun.gupt 889 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
890 
    """
891 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 892 
 
4600 varun.gupt 893 
    Parameters:
894 
     - vendorId
895 
     - billingDateFrom
896 
     - billingDateTo
897 
    """
898 
    pass
899 
 
4607 rajveer 900 
  def getSlippedSippingDateOrders(self, ):
901 
    pass
902 
 
4600 varun.gupt 903 
  def saveBluedartSettlements(self, mapAWBAndAmount):
904 
    """
905 
    Parameters:
906 
     - mapAWBAndAmount
907 
    """
908 
    pass
909 
 
910 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
911 
    """
912 
    Parameters:
913 
     - settlementDate
914 
     - paymentGatewayId
915 
     - paymentId
916 
     - serviceTax
917 
     - otherCharges
918 
     - netCollection
919 
    """
920 
    pass
921 
 
922 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
923 
    """
924 
    Parameters:
925 
     - settlementId
926 
     - settlementDate
927 
     - transactionDateFrom
928 
     - transactionDateTo
929 
     - amount
930 
    """
931 
    pass
932 
 
933 
  def getSettlementForPaymentId(self, paymentId):
934 
    """
935 
    Parameters:
936 
     - paymentId
937 
    """
938 
    pass
939 
 
940 
  def getEBSSettlementSummaries(self, ):
941 
    pass
942 
 
943 
  def markEBSSettlementUploaded(self, settlementId):
944 
    """
945 
    Parameters:
946 
     - settlementId
947 
    """
948 
    pass
949 
 
950 
  def getEBSSettlementDate(self, settlementId):
951 
    """
952 
    Parameters:
953 
     - settlementId
954 
    """
955 
    pass
956 
 
957 
 
3376 rajveer 958 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 959 
  def __init__(self, iprot, oprot=None):
3376 rajveer 960 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 961 
 
962 
  def createTransaction(self, transaction):
963 
    """
964 
    Parameters:
965 
     - transaction
966 
    """
967 
    self.send_createTransaction(transaction)
132 ashish 968 
    return self.recv_createTransaction()
94 ashish 969 
 
970 
  def send_createTransaction(self, transaction):
971 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
972 
    args = createTransaction_args()
973 
    args.transaction = transaction
974 
    args.write(self._oprot)
975 
    self._oprot.writeMessageEnd()
976 
    self._oprot.trans.flush()
977 
 
978 
  def recv_createTransaction(self, ):
979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
980 
    if mtype == TMessageType.EXCEPTION:
981 
      x = TApplicationException()
982 
      x.read(self._iprot)
983 
      self._iprot.readMessageEnd()
984 
      raise x
985 
    result = createTransaction_result()
986 
    result.read(self._iprot)
987 
    self._iprot.readMessageEnd()
3431 rajveer 988 
    if result.success is not None:
132 ashish 989 
      return result.success
3431 rajveer 990 
    if result.ex is not None:
94 ashish 991 
      raise result.ex
132 ashish 992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 993 
 
994 
  def getTransaction(self, id):
995 
    """
996 
    Parameters:
997 
     - id
998 
    """
999 
    self.send_getTransaction(id)
1000 
    return self.recv_getTransaction()
1001 
 
1002 
  def send_getTransaction(self, id):
1003 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1004 
    args = getTransaction_args()
1005 
    args.id = id
1006 
    args.write(self._oprot)
1007 
    self._oprot.writeMessageEnd()
1008 
    self._oprot.trans.flush()
1009 
 
1010 
  def recv_getTransaction(self, ):
1011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1012 
    if mtype == TMessageType.EXCEPTION:
1013 
      x = TApplicationException()
1014 
      x.read(self._iprot)
1015 
      self._iprot.readMessageEnd()
1016 
      raise x
1017 
    result = getTransaction_result()
1018 
    result.read(self._iprot)
1019 
    self._iprot.readMessageEnd()
3431 rajveer 1020 
    if result.success is not None:
94 ashish 1021 
      return result.success
3431 rajveer 1022 
    if result.ex is not None:
94 ashish 1023 
      raise result.ex
1024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1025 
 
1026 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1027 
    """
1028 
    Parameters:
1029 
     - customerId
1030 
     - from_date
1031 
     - to_date
1032 
     - status
1033 
    """
1034 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1035 
    return self.recv_getTransactionsForCustomer()
1036 
 
1037 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1038 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1039 
    args = getTransactionsForCustomer_args()
1040 
    args.customerId = customerId
1041 
    args.from_date = from_date
1042 
    args.to_date = to_date
1043 
    args.status = status
1044 
    args.write(self._oprot)
1045 
    self._oprot.writeMessageEnd()
1046 
    self._oprot.trans.flush()
1047 
 
1048 
  def recv_getTransactionsForCustomer(self, ):
1049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1050 
    if mtype == TMessageType.EXCEPTION:
1051 
      x = TApplicationException()
1052 
      x.read(self._iprot)
1053 
      self._iprot.readMessageEnd()
1054 
      raise x
1055 
    result = getTransactionsForCustomer_result()
1056 
    result.read(self._iprot)
1057 
    self._iprot.readMessageEnd()
3431 rajveer 1058 
    if result.success is not None:
94 ashish 1059 
      return result.success
3431 rajveer 1060 
    if result.ex is not None:
94 ashish 1061 
      raise result.ex
1062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1063 
 
132 ashish 1064 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1065 
    """
1066 
    Parameters:
1067 
     - shoppingCartId
1068 
    """
1069 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1070 
    return self.recv_getTransactionsForShoppingCartId()
1071 
 
1072 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1073 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1074 
    args = getTransactionsForShoppingCartId_args()
1075 
    args.shoppingCartId = shoppingCartId
1076 
    args.write(self._oprot)
1077 
    self._oprot.writeMessageEnd()
1078 
    self._oprot.trans.flush()
1079 
 
1080 
  def recv_getTransactionsForShoppingCartId(self, ):
1081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1082 
    if mtype == TMessageType.EXCEPTION:
1083 
      x = TApplicationException()
1084 
      x.read(self._iprot)
1085 
      self._iprot.readMessageEnd()
1086 
      raise x
1087 
    result = getTransactionsForShoppingCartId_result()
1088 
    result.read(self._iprot)
1089 
    self._iprot.readMessageEnd()
3431 rajveer 1090 
    if result.success is not None:
132 ashish 1091 
      return result.success
3431 rajveer 1092 
    if result.ex is not None:
132 ashish 1093 
      raise result.ex
1094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1095 
 
94 ashish 1096 
  def getTransactionStatus(self, transactionId):
1097 
    """
1098 
    Parameters:
1099 
     - transactionId
1100 
    """
1101 
    self.send_getTransactionStatus(transactionId)
1102 
    return self.recv_getTransactionStatus()
1103 
 
1104 
  def send_getTransactionStatus(self, transactionId):
1105 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1106 
    args = getTransactionStatus_args()
1107 
    args.transactionId = transactionId
1108 
    args.write(self._oprot)
1109 
    self._oprot.writeMessageEnd()
1110 
    self._oprot.trans.flush()
1111 
 
1112 
  def recv_getTransactionStatus(self, ):
1113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1114 
    if mtype == TMessageType.EXCEPTION:
1115 
      x = TApplicationException()
1116 
      x.read(self._iprot)
1117 
      self._iprot.readMessageEnd()
1118 
      raise x
1119 
    result = getTransactionStatus_result()
1120 
    result.read(self._iprot)
1121 
    self._iprot.readMessageEnd()
3431 rajveer 1122 
    if result.success is not None:
94 ashish 1123 
      return result.success
3431 rajveer 1124 
    if result.ex is not None:
94 ashish 1125 
      raise result.ex
1126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1127 
 
1128 
  def changeTransactionStatus(self, transactionId, status, description):
1129 
    """
1130 
    Parameters:
1131 
     - transactionId
1132 
     - status
1133 
     - description
1134 
    """
1135 
    self.send_changeTransactionStatus(transactionId, status, description)
1136 
    return self.recv_changeTransactionStatus()
1137 
 
1138 
  def send_changeTransactionStatus(self, transactionId, status, description):
1139 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1140 
    args = changeTransactionStatus_args()
1141 
    args.transactionId = transactionId
1142 
    args.status = status
1143 
    args.description = description
1144 
    args.write(self._oprot)
1145 
    self._oprot.writeMessageEnd()
1146 
    self._oprot.trans.flush()
1147 
 
1148 
  def recv_changeTransactionStatus(self, ):
1149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1150 
    if mtype == TMessageType.EXCEPTION:
1151 
      x = TApplicationException()
1152 
      x.read(self._iprot)
1153 
      self._iprot.readMessageEnd()
1154 
      raise x
1155 
    result = changeTransactionStatus_result()
1156 
    result.read(self._iprot)
1157 
    self._iprot.readMessageEnd()
3431 rajveer 1158 
    if result.success is not None:
94 ashish 1159 
      return result.success
3431 rajveer 1160 
    if result.ex is not None:
94 ashish 1161 
      raise result.ex
1162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1163 
 
1398 varun.gupt 1164 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1165 
    """
1166 
    Parameters:
1167 
     - transactionId
1168 
    """
1398 varun.gupt 1169 
    self.send_enqueueTransactionInfoEmail(transactionId)
1170 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1171 
 
1398 varun.gupt 1172 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1173 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1174 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1175 
    args.transactionId = transactionId
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1398 varun.gupt 1180 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1398 varun.gupt 1187 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
3431 rajveer 1190 
    if result.success is not None:
1382 varun.gupt 1191 
      return result.success
3431 rajveer 1192 
    if result.ex is not None:
1382 varun.gupt 1193 
      raise result.ex
1398 varun.gupt 1194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1195 
 
483 rajveer 1196 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1197 
    """
1198 
    Parameters:
483 rajveer 1199 
     - status
1200 
     - from_date
1201 
     - to_date
1202 
     - warehouse_id
94 ashish 1203 
    """
483 rajveer 1204 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1205 
    return self.recv_getAllOrders()
94 ashish 1206 
 
483 rajveer 1207 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1208 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1209 
    args = getAllOrders_args()
1210 
    args.status = status
1211 
    args.from_date = from_date
1212 
    args.to_date = to_date
1213 
    args.warehouse_id = warehouse_id
94 ashish 1214 
    args.write(self._oprot)
1215 
    self._oprot.writeMessageEnd()
1216 
    self._oprot.trans.flush()
1217 
 
483 rajveer 1218 
  def recv_getAllOrders(self, ):
94 ashish 1219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1220 
    if mtype == TMessageType.EXCEPTION:
1221 
      x = TApplicationException()
1222 
      x.read(self._iprot)
1223 
      self._iprot.readMessageEnd()
1224 
      raise x
483 rajveer 1225 
    result = getAllOrders_result()
94 ashish 1226 
    result.read(self._iprot)
1227 
    self._iprot.readMessageEnd()
3431 rajveer 1228 
    if result.success is not None:
94 ashish 1229 
      return result.success
3431 rajveer 1230 
    if result.ex is not None:
94 ashish 1231 
      raise result.ex
483 rajveer 1232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1233 
 
4133 chandransh 1234 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1235 
    """
1236 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1237 
    Pass the status as null and the limit as 0 to ignore them.
1238 
 
1239 
    Parameters:
1240 
     - statuses
1241 
     - offset
1242 
     - limit
1243 
     - warehouse_id
1244 
    """
1245 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1246 
    return self.recv_getOrdersInBatch()
1247 
 
1248 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1249 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1250 
    args = getOrdersInBatch_args()
1251 
    args.statuses = statuses
1252 
    args.offset = offset
1253 
    args.limit = limit
1254 
    args.warehouse_id = warehouse_id
1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_getOrdersInBatch(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = getOrdersInBatch_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
1269 
    if result.success is not None:
1270 
      return result.success
1271 
    if result.ex is not None:
1272 
      raise result.ex
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1274 
 
1275 
  def getOrderCount(self, statuses, warehouseId):
1276 
    """
1277 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1278 
 
1279 
    Parameters:
1280 
     - statuses
1281 
     - warehouseId
1282 
    """
1283 
    self.send_getOrderCount(statuses, warehouseId)
1284 
    return self.recv_getOrderCount()
1285 
 
1286 
  def send_getOrderCount(self, statuses, warehouseId):
1287 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1288 
    args = getOrderCount_args()
1289 
    args.statuses = statuses
1290 
    args.warehouseId = warehouseId
1291 
    args.write(self._oprot)
1292 
    self._oprot.writeMessageEnd()
1293 
    self._oprot.trans.flush()
1294 
 
1295 
  def recv_getOrderCount(self, ):
1296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1297 
    if mtype == TMessageType.EXCEPTION:
1298 
      x = TApplicationException()
1299 
      x.read(self._iprot)
1300 
      self._iprot.readMessageEnd()
1301 
      raise x
1302 
    result = getOrderCount_result()
1303 
    result.read(self._iprot)
1304 
    self._iprot.readMessageEnd()
1305 
    if result.success is not None:
1306 
      return result.success
1307 
    if result.ex is not None:
1308 
      raise result.ex
1309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1310 
 
999 varun.gupt 1311 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1312 
    """
1132 chandransh 1313 
    Returns orders within a range of their billing dates
3431 rajveer 1314 
 
999 varun.gupt 1315 
    Parameters:
1316 
     - status
1317 
     - start_billing_date
1318 
     - end_billing_date
1319 
     - warehouse_id
1320 
    """
1321 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1322 
    return self.recv_getOrdersByBillingDate()
1323 
 
1324 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1325 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1326 
    args = getOrdersByBillingDate_args()
1327 
    args.status = status
1328 
    args.start_billing_date = start_billing_date
1329 
    args.end_billing_date = end_billing_date
1330 
    args.warehouse_id = warehouse_id
1331 
    args.write(self._oprot)
1332 
    self._oprot.writeMessageEnd()
1333 
    self._oprot.trans.flush()
1334 
 
1335 
  def recv_getOrdersByBillingDate(self, ):
1336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1337 
    if mtype == TMessageType.EXCEPTION:
1338 
      x = TApplicationException()
1339 
      x.read(self._iprot)
1340 
      self._iprot.readMessageEnd()
1341 
      raise x
1342 
    result = getOrdersByBillingDate_result()
1343 
    result.read(self._iprot)
1344 
    self._iprot.readMessageEnd()
3431 rajveer 1345 
    if result.success is not None:
999 varun.gupt 1346 
      return result.success
3431 rajveer 1347 
    if result.ex is not None:
999 varun.gupt 1348 
      raise result.ex
1349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1350 
 
3451 chandransh 1351 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1352 
    """
1353 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1354 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1355 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1356 
 
3427 chandransh 1357 
    Parameters:
1358 
     - fromShippingDate
1359 
     - toShippingDate
1360 
     - providerId
1361 
     - warehouseId
3451 chandransh 1362 
     - cod
3427 chandransh 1363 
    """
3451 chandransh 1364 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1365 
    return self.recv_getOrdersByShippingDate()
1366 
 
3451 chandransh 1367 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1368 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1369 
    args = getOrdersByShippingDate_args()
1370 
    args.fromShippingDate = fromShippingDate
1371 
    args.toShippingDate = toShippingDate
1372 
    args.providerId = providerId
1373 
    args.warehouseId = warehouseId
3451 chandransh 1374 
    args.cod = cod
3427 chandransh 1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1379 
  def recv_getOrdersByShippingDate(self, ):
1380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1381 
    if mtype == TMessageType.EXCEPTION:
1382 
      x = TApplicationException()
1383 
      x.read(self._iprot)
1384 
      self._iprot.readMessageEnd()
1385 
      raise x
1386 
    result = getOrdersByShippingDate_result()
1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
3431 rajveer 1389 
    if result.success is not None:
3427 chandransh 1390 
      return result.success
3431 rajveer 1391 
    if result.ex is not None:
3427 chandransh 1392 
      raise result.ex
1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1394 
 
1382 varun.gupt 1395 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1396 
    """
1397 
    Returns order ids for orders which can be returned
3431 rajveer 1398 
 
1382 varun.gupt 1399 
    Parameters:
1400 
     - customer_id
1401 
     - limit
1402 
    """
1403 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1404 
    return self.recv_getReturnableOrdersForCustomer()
1405 
 
1406 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1407 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1408 
    args = getReturnableOrdersForCustomer_args()
1409 
    args.customer_id = customer_id
1410 
    args.limit = limit
1411 
    args.write(self._oprot)
1412 
    self._oprot.writeMessageEnd()
1413 
    self._oprot.trans.flush()
1414 
 
1415 
  def recv_getReturnableOrdersForCustomer(self, ):
1416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1417 
    if mtype == TMessageType.EXCEPTION:
1418 
      x = TApplicationException()
1419 
      x.read(self._iprot)
1420 
      self._iprot.readMessageEnd()
1421 
      raise x
1422 
    result = getReturnableOrdersForCustomer_result()
1423 
    result.read(self._iprot)
1424 
    self._iprot.readMessageEnd()
3431 rajveer 1425 
    if result.success is not None:
1382 varun.gupt 1426 
      return result.success
3431 rajveer 1427 
    if result.ex is not None:
1382 varun.gupt 1428 
      raise result.ex
1429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1430 
 
1431 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1432 
    """
1433 
    Returns order ids for orders which can be cancelled
3431 rajveer 1434 
 
1382 varun.gupt 1435 
    Parameters:
1436 
     - customer_id
1437 
     - limit
1438 
    """
1439 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1440 
    return self.recv_getCancellableOrdersForCustomer()
1441 
 
1442 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1443 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1444 
    args = getCancellableOrdersForCustomer_args()
1445 
    args.customer_id = customer_id
1446 
    args.limit = limit
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_getCancellableOrdersForCustomer(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = getCancellableOrdersForCustomer_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
3431 rajveer 1461 
    if result.success is not None:
1382 varun.gupt 1462 
      return result.success
3431 rajveer 1463 
    if result.ex is not None:
1382 varun.gupt 1464 
      raise result.ex
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1466 
 
483 rajveer 1467 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1468 
    """
1469 
    Parameters:
483 rajveer 1470 
     - orderId
1471 
     - status
1472 
     - description
94 ashish 1473 
    """
483 rajveer 1474 
    self.send_changeOrderStatus(orderId, status, description)
1475 
    return self.recv_changeOrderStatus()
94 ashish 1476 
 
483 rajveer 1477 
  def send_changeOrderStatus(self, orderId, status, description):
1478 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1479 
    args = changeOrderStatus_args()
1480 
    args.orderId = orderId
1481 
    args.status = status
1482 
    args.description = description
94 ashish 1483 
    args.write(self._oprot)
1484 
    self._oprot.writeMessageEnd()
1485 
    self._oprot.trans.flush()
1486 
 
483 rajveer 1487 
  def recv_changeOrderStatus(self, ):
94 ashish 1488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1489 
    if mtype == TMessageType.EXCEPTION:
1490 
      x = TApplicationException()
1491 
      x.read(self._iprot)
1492 
      self._iprot.readMessageEnd()
1493 
      raise x
483 rajveer 1494 
    result = changeOrderStatus_result()
94 ashish 1495 
    result.read(self._iprot)
1496 
    self._iprot.readMessageEnd()
3431 rajveer 1497 
    if result.success is not None:
94 ashish 1498 
      return result.success
3431 rajveer 1499 
    if result.ex is not None:
94 ashish 1500 
      raise result.ex
483 rajveer 1501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1502 
 
1528 ankur.sing 1503 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1504 
    """
1528 ankur.sing 1505 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1506 
    only user who owns the transaction can view its order details.
3431 rajveer 1507 
 
94 ashish 1508 
    Parameters:
1509 
     - transactionId
1528 ankur.sing 1510 
     - customerId
94 ashish 1511 
    """
1528 ankur.sing 1512 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1513 
    return self.recv_getOrdersForTransaction()
94 ashish 1514 
 
1528 ankur.sing 1515 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1516 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1517 
    args = getOrdersForTransaction_args()
94 ashish 1518 
    args.transactionId = transactionId
1528 ankur.sing 1519 
    args.customerId = customerId
94 ashish 1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
483 rajveer 1524 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
483 rajveer 1531 
    result = getOrdersForTransaction_result()
94 ashish 1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
3431 rajveer 1534 
    if result.success is not None:
94 ashish 1535 
      return result.success
3431 rajveer 1536 
    if result.ex is not None:
94 ashish 1537 
      raise result.ex
483 rajveer 1538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1539 
 
3014 chandransh 1540 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1541 
    """
3014 chandransh 1542 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1543 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1544 
 
94 ashish 1545 
    Parameters:
483 rajveer 1546 
     - customerId
1547 
     - from_date
1548 
     - to_date
3014 chandransh 1549 
     - statuses
94 ashish 1550 
    """
3014 chandransh 1551 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1552 
    return self.recv_getOrdersForCustomer()
94 ashish 1553 
 
3014 chandransh 1554 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1555 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1556 
    args = getOrdersForCustomer_args()
1557 
    args.customerId = customerId
1558 
    args.from_date = from_date
1559 
    args.to_date = to_date
3014 chandransh 1560 
    args.statuses = statuses
94 ashish 1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
483 rajveer 1565 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
483 rajveer 1572 
    result = getOrdersForCustomer_result()
94 ashish 1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
3431 rajveer 1575 
    if result.success is not None:
94 ashish 1576 
      return result.success
3431 rajveer 1577 
    if result.ex is not None:
94 ashish 1578 
      raise result.ex
483 rajveer 1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1580 
 
483 rajveer 1581 
  def createOrder(self, order):
94 ashish 1582 
    """
1583 
    Parameters:
483 rajveer 1584 
     - order
94 ashish 1585 
    """
483 rajveer 1586 
    self.send_createOrder(order)
1587 
    return self.recv_createOrder()
94 ashish 1588 
 
483 rajveer 1589 
  def send_createOrder(self, order):
1590 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1591 
    args = createOrder_args()
1592 
    args.order = order
94 ashish 1593 
    args.write(self._oprot)
1594 
    self._oprot.writeMessageEnd()
1595 
    self._oprot.trans.flush()
1596 
 
483 rajveer 1597 
  def recv_createOrder(self, ):
94 ashish 1598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1599 
    if mtype == TMessageType.EXCEPTION:
1600 
      x = TApplicationException()
1601 
      x.read(self._iprot)
1602 
      self._iprot.readMessageEnd()
1603 
      raise x
483 rajveer 1604 
    result = createOrder_result()
94 ashish 1605 
    result.read(self._iprot)
1606 
    self._iprot.readMessageEnd()
3431 rajveer 1607 
    if result.success is not None:
94 ashish 1608 
      return result.success
3431 rajveer 1609 
    if result.ex is not None:
94 ashish 1610 
      raise result.ex
483 rajveer 1611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1612 
 
483 rajveer 1613 
  def getOrder(self, id):
94 ashish 1614 
    """
1615 
    Parameters:
483 rajveer 1616 
     - id
94 ashish 1617 
    """
483 rajveer 1618 
    self.send_getOrder(id)
1619 
    return self.recv_getOrder()
94 ashish 1620 
 
483 rajveer 1621 
  def send_getOrder(self, id):
1622 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1623 
    args = getOrder_args()
1624 
    args.id = id
94 ashish 1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
483 rajveer 1629 
  def recv_getOrder(self, ):
94 ashish 1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
483 rajveer 1636 
    result = getOrder_result()
94 ashish 1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
3431 rajveer 1639 
    if result.success is not None:
94 ashish 1640 
      return result.success
3431 rajveer 1641 
    if result.ex is not None:
94 ashish 1642 
      raise result.ex
483 rajveer 1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1644 
 
483 rajveer 1645 
  def getLineItemsForOrder(self, orderId):
94 ashish 1646 
    """
1647 
    Parameters:
483 rajveer 1648 
     - orderId
94 ashish 1649 
    """
483 rajveer 1650 
    self.send_getLineItemsForOrder(orderId)
1651 
    return self.recv_getLineItemsForOrder()
94 ashish 1652 
 
483 rajveer 1653 
  def send_getLineItemsForOrder(self, orderId):
1654 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1655 
    args = getLineItemsForOrder_args()
1656 
    args.orderId = orderId
94 ashish 1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
483 rajveer 1661 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
483 rajveer 1668 
    result = getLineItemsForOrder_result()
94 ashish 1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
3431 rajveer 1671 
    if result.success is not None:
94 ashish 1672 
      return result.success
3431 rajveer 1673 
    if result.ex is not None:
94 ashish 1674 
      raise result.ex
483 rajveer 1675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1676 
 
1528 ankur.sing 1677 
  def getOrderForCustomer(self, orderId, customerId):
1678 
    """
1679 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1680 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1681 
 
1528 ankur.sing 1682 
    Parameters:
1683 
     - orderId
1684 
     - customerId
1685 
    """
1686 
    self.send_getOrderForCustomer(orderId, customerId)
1687 
    return self.recv_getOrderForCustomer()
1688 
 
1689 
  def send_getOrderForCustomer(self, orderId, customerId):
1690 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1691 
    args = getOrderForCustomer_args()
1692 
    args.orderId = orderId
1693 
    args.customerId = customerId
1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1698 
  def recv_getOrderForCustomer(self, ):
1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1705 
    result = getOrderForCustomer_result()
1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
3431 rajveer 1708 
    if result.success is not None:
1528 ankur.sing 1709 
      return result.success
3431 rajveer 1710 
    if result.ex is not None:
1528 ankur.sing 1711 
      raise result.ex
1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1713 
 
4444 rajveer 1714 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1715 
    """
1716 
    Parameters:
4394 rajveer 1717 
     - type
4444 rajveer 1718 
     - warehouseId
4394 rajveer 1719 
     - status
1720 
     - timestamp
3064 chandransh 1721 
    """
4444 rajveer 1722 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1723 
    return self.recv_getAlerts()
1724 
 
4444 rajveer 1725 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1726 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1727 
    args = getAlerts_args()
4394 rajveer 1728 
    args.type = type
4444 rajveer 1729 
    args.warehouseId = warehouseId
4394 rajveer 1730 
    args.status = status
1731 
    args.timestamp = timestamp
3064 chandransh 1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getAlerts(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getAlerts_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
3431 rajveer 1746 
    if result.success is not None:
3064 chandransh 1747 
      return result.success
1748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1749 
 
4444 rajveer 1750 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1751 
    """
1752 
    Parameters:
1753 
     - type
4444 rajveer 1754 
     - warehouseId
4394 rajveer 1755 
     - description
3064 chandransh 1756 
    """
4444 rajveer 1757 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1758 
    self.recv_addAlert()
3064 chandransh 1759 
 
4444 rajveer 1760 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1761 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1762 
    args = addAlert_args()
3064 chandransh 1763 
    args.type = type
4444 rajveer 1764 
    args.warehouseId = warehouseId
4394 rajveer 1765 
    args.description = description
3064 chandransh 1766 
    args.write(self._oprot)
1767 
    self._oprot.writeMessageEnd()
1768 
    self._oprot.trans.flush()
1769 
 
4394 rajveer 1770 
  def recv_addAlert(self, ):
3064 chandransh 1771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1772 
    if mtype == TMessageType.EXCEPTION:
1773 
      x = TApplicationException()
1774 
      x.read(self._iprot)
1775 
      self._iprot.readMessageEnd()
1776 
      raise x
4394 rajveer 1777 
    result = addAlert_result()
3064 chandransh 1778 
    result.read(self._iprot)
1779 
    self._iprot.readMessageEnd()
1780 
    return
1781 
 
4444 rajveer 1782 
  def markAlertsAsSeen(self, warehouseId):
1783 
    """
1784 
    Parameters:
1785 
     - warehouseId
1786 
    """
1787 
    self.send_markAlertsAsSeen(warehouseId)
1788 
    self.recv_markAlertsAsSeen()
1789 
 
1790 
  def send_markAlertsAsSeen(self, warehouseId):
1791 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1792 
    args = markAlertsAsSeen_args()
1793 
    args.warehouseId = warehouseId
1794 
    args.write(self._oprot)
1795 
    self._oprot.writeMessageEnd()
1796 
    self._oprot.trans.flush()
1797 
 
1798 
  def recv_markAlertsAsSeen(self, ):
1799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1800 
    if mtype == TMessageType.EXCEPTION:
1801 
      x = TApplicationException()
1802 
      x.read(self._iprot)
1803 
      self._iprot.readMessageEnd()
1804 
      raise x
1805 
    result = markAlertsAsSeen_result()
1806 
    result.read(self._iprot)
1807 
    self._iprot.readMessageEnd()
1808 
    return
1809 
 
3064 chandransh 1810 
  def getValidOrderCount(self, ):
1811 
    """
1812 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1813 
    """
1814 
    self.send_getValidOrderCount()
1815 
    return self.recv_getValidOrderCount()
1816 
 
1817 
  def send_getValidOrderCount(self, ):
1818 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1819 
    args = getValidOrderCount_args()
1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
1824 
  def recv_getValidOrderCount(self, ):
1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
1831 
    result = getValidOrderCount_result()
1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
3431 rajveer 1834 
    if result.success is not None:
3064 chandransh 1835 
      return result.success
1836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1837 
 
1838 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1839 
    """
1840 
    Returns the number of distinct customers who have done successful transactions
1841 
    """
1842 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1843 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1844 
 
1845 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1846 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1847 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
3431 rajveer 1862 
    if result.success is not None:
3064 chandransh 1863 
      return result.success
1864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1865 
 
1866 
  def getValidOrdersAmountRange(self, ):
1867 
    """
1868 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1869 
    List contains two values, first minimum amount and second maximum amount.
1870 
    """
1871 
    self.send_getValidOrdersAmountRange()
1872 
    return self.recv_getValidOrdersAmountRange()
1873 
 
1874 
  def send_getValidOrdersAmountRange(self, ):
1875 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1876 
    args = getValidOrdersAmountRange_args()
1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getValidOrdersAmountRange(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getValidOrdersAmountRange_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
3064 chandransh 1892 
      return result.success
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1894 
 
1895 
  def getValidOrders(self, limit):
1896 
    """
1897 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1898 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1899 
 
3064 chandransh 1900 
    Parameters:
1901 
     - limit
1902 
    """
1903 
    self.send_getValidOrders(limit)
1904 
    return self.recv_getValidOrders()
1905 
 
1906 
  def send_getValidOrders(self, limit):
1907 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1908 
    args = getValidOrders_args()
1909 
    args.limit = limit
1910 
    args.write(self._oprot)
1911 
    self._oprot.writeMessageEnd()
1912 
    self._oprot.trans.flush()
1913 
 
1914 
  def recv_getValidOrders(self, ):
1915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1916 
    if mtype == TMessageType.EXCEPTION:
1917 
      x = TApplicationException()
1918 
      x.read(self._iprot)
1919 
      self._iprot.readMessageEnd()
1920 
      raise x
1921 
    result = getValidOrders_result()
1922 
    result.read(self._iprot)
1923 
    self._iprot.readMessageEnd()
3431 rajveer 1924 
    if result.success is not None:
3064 chandransh 1925 
      return result.success
1926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1927 
 
1220 chandransh 1928 
  def batchOrders(self, warehouseId):
1929 
    """
1930 
    Create a batch of all the pending orders for the given warehouse.
1931 
    The returned list is orderd by created_timestamp.
1932 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1933 
 
1220 chandransh 1934 
    Parameters:
1935 
     - warehouseId
1936 
    """
1937 
    self.send_batchOrders(warehouseId)
1938 
    return self.recv_batchOrders()
1939 
 
1940 
  def send_batchOrders(self, warehouseId):
1941 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1942 
    args = batchOrders_args()
1943 
    args.warehouseId = warehouseId
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_batchOrders(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = batchOrders_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
3431 rajveer 1958 
    if result.success is not None:
1220 chandransh 1959 
      return result.success
3431 rajveer 1960 
    if result.ex is not None:
1220 chandransh 1961 
      raise result.ex
1962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1963 
 
1208 chandransh 1964 
  def markOrderAsOutOfStock(self, orderId):
1965 
    """
1966 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1967 
 
1208 chandransh 1968 
    Parameters:
1969 
     - orderId
1970 
    """
1971 
    self.send_markOrderAsOutOfStock(orderId)
1972 
    return self.recv_markOrderAsOutOfStock()
1973 
 
1974 
  def send_markOrderAsOutOfStock(self, orderId):
1975 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1976 
    args = markOrderAsOutOfStock_args()
1977 
    args.orderId = orderId
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_markOrderAsOutOfStock(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = markOrderAsOutOfStock_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
3431 rajveer 1992 
    if result.success is not None:
1208 chandransh 1993 
      return result.success
3431 rajveer 1994 
    if result.ex is not None:
1208 chandransh 1995 
      raise result.ex
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1997 
 
3064 chandransh 1998 
  def verifyOrder(self, orderId):
759 chandransh 1999 
    """
3064 chandransh 2000 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2001 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2002 
    used for all other orders as well.
2003 
    Throws an exception if no such order exists.
3431 rajveer 2004 
 
759 chandransh 2005 
    Parameters:
3064 chandransh 2006 
     - orderId
759 chandransh 2007 
    """
3064 chandransh 2008 
    self.send_verifyOrder(orderId)
2009 
    return self.recv_verifyOrder()
759 chandransh 2010 
 
3064 chandransh 2011 
  def send_verifyOrder(self, orderId):
2012 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2013 
    args = verifyOrder_args()
2014 
    args.orderId = orderId
759 chandransh 2015 
    args.write(self._oprot)
2016 
    self._oprot.writeMessageEnd()
2017 
    self._oprot.trans.flush()
2018 
 
3064 chandransh 2019 
  def recv_verifyOrder(self, ):
759 chandransh 2020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2021 
    if mtype == TMessageType.EXCEPTION:
2022 
      x = TApplicationException()
2023 
      x.read(self._iprot)
2024 
      self._iprot.readMessageEnd()
2025 
      raise x
3064 chandransh 2026 
    result = verifyOrder_result()
759 chandransh 2027 
    result.read(self._iprot)
2028 
    self._iprot.readMessageEnd()
3431 rajveer 2029 
    if result.success is not None:
759 chandransh 2030 
      return result.success
3431 rajveer 2031 
    if result.ex is not None:
759 chandransh 2032 
      raise result.ex
3064 chandransh 2033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2034 
 
3064 chandransh 2035 
  def acceptOrder(self, orderId):
1113 chandransh 2036 
    """
3064 chandransh 2037 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2038 
    given order is not a COD order, it also captures the payment if the same has
2039 
    not been captured.
2040 
    Throws an exception if no such order exists.
3431 rajveer 2041 
 
1113 chandransh 2042 
    Parameters:
3064 chandransh 2043 
     - orderId
1113 chandransh 2044 
    """
3064 chandransh 2045 
    self.send_acceptOrder(orderId)
2046 
    return self.recv_acceptOrder()
1113 chandransh 2047 
 
3064 chandransh 2048 
  def send_acceptOrder(self, orderId):
2049 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2050 
    args = acceptOrder_args()
2051 
    args.orderId = orderId
1113 chandransh 2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
3064 chandransh 2056 
  def recv_acceptOrder(self, ):
1113 chandransh 2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
3064 chandransh 2063 
    result = acceptOrder_result()
1113 chandransh 2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
1113 chandransh 2067 
      return result.success
3431 rajveer 2068 
    if result.ex is not None:
1113 chandransh 2069 
      raise result.ex
3064 chandransh 2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2071 
 
4283 anupam.sin 2072 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2073 
    """
3064 chandransh 2074 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2075 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2076 
    the IMEI no. if a -1 is supplied.
2077 
    Also, it generates an invoice number for the order, marks the order as
2078 
    BILLED and sets the billing timestamp.
2079 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2080 
 
1135 chandransh 2081 
    Parameters:
3064 chandransh 2082 
     - orderId
2083 
     - invoice_number
4283 anupam.sin 2084 
     - imeiNumber
2085 
     - itemNumber
3064 chandransh 2086 
     - billed_by
4264 rajveer 2087 
     - jacketNumber
4283 anupam.sin 2088 
     - billingType
2089 
     - vendorId
1135 chandransh 2090 
    """
4283 anupam.sin 2091 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2092 
    return self.recv_addBillingDetails()
1135 chandransh 2093 
 
4283 anupam.sin 2094 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2095 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2096 
    args = addBillingDetails_args()
2097 
    args.orderId = orderId
2098 
    args.invoice_number = invoice_number
4283 anupam.sin 2099 
    args.imeiNumber = imeiNumber
2100 
    args.itemNumber = itemNumber
3064 chandransh 2101 
    args.billed_by = billed_by
4264 rajveer 2102 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2103 
    args.billingType = billingType
2104 
    args.vendorId = vendorId
1135 chandransh 2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
3064 chandransh 2109 
  def recv_addBillingDetails(self, ):
1135 chandransh 2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
3064 chandransh 2116 
    result = addBillingDetails_result()
1135 chandransh 2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
3431 rajveer 2119 
    if result.success is not None:
3064 chandransh 2120 
      return result.success
3431 rajveer 2121 
    if result.ex is not None:
1135 chandransh 2122 
      raise result.ex
3064 chandransh 2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2124 
 
4579 rajveer 2125 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2126 
    """
2127 
    Add the invoice number to the order.
2128 
 
2129 
    Parameters:
2130 
     - orderId
2131 
     - invoiceNumber
2132 
    """
2133 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2134 
    self.recv_addInvoiceNumber()
2135 
 
2136 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2137 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2138 
    args = addInvoiceNumber_args()
2139 
    args.orderId = orderId
2140 
    args.invoiceNumber = invoiceNumber
2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
2145 
  def recv_addInvoiceNumber(self, ):
2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
2152 
    result = addInvoiceNumber_result()
2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
2155 
    if result.ex is not None:
2156 
      raise result.ex
2157 
    return
2158 
 
3064 chandransh 2159 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2160 
    """
3064 chandransh 2161 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2162 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2163 
 
1408 ankur.sing 2164 
    Parameters:
3064 chandransh 2165 
     - warehouseId
1408 ankur.sing 2166 
     - providerId
3064 chandransh 2167 
     - cod
1408 ankur.sing 2168 
    """
3064 chandransh 2169 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2170 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2171 
 
3064 chandransh 2172 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2173 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2174 
    args = markOrdersAsManifested_args()
2175 
    args.warehouseId = warehouseId
1408 ankur.sing 2176 
    args.providerId = providerId
3064 chandransh 2177 
    args.cod = cod
1408 ankur.sing 2178 
    args.write(self._oprot)
2179 
    self._oprot.writeMessageEnd()
2180 
    self._oprot.trans.flush()
2181 
 
3064 chandransh 2182 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2184 
    if mtype == TMessageType.EXCEPTION:
2185 
      x = TApplicationException()
2186 
      x.read(self._iprot)
2187 
      self._iprot.readMessageEnd()
2188 
      raise x
3064 chandransh 2189 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2190 
    result.read(self._iprot)
2191 
    self._iprot.readMessageEnd()
3431 rajveer 2192 
    if result.success is not None:
1408 ankur.sing 2193 
      return result.success
3431 rajveer 2194 
    if result.ex is not None:
3064 chandransh 2195 
      raise result.ex
2196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2197 
 
4410 rajveer 2198 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2199 
    """
2200 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2201 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2202 
 
2203 
    Parameters:
2204 
     - warehouseId
2205 
     - providerId
2206 
     - cod
2207 
    """
2208 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2209 
    return self.recv_markOrdersAsShippedFromWarehouse()
2210 
 
2211 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2212 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2213 
    args = markOrdersAsShippedFromWarehouse_args()
2214 
    args.warehouseId = warehouseId
2215 
    args.providerId = providerId
2216 
    args.cod = cod
2217 
    args.write(self._oprot)
2218 
    self._oprot.writeMessageEnd()
2219 
    self._oprot.trans.flush()
2220 
 
2221 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2223 
    if mtype == TMessageType.EXCEPTION:
2224 
      x = TApplicationException()
2225 
      x.read(self._iprot)
2226 
      self._iprot.readMessageEnd()
2227 
      raise x
2228 
    result = markOrdersAsShippedFromWarehouse_result()
2229 
    result.read(self._iprot)
2230 
    self._iprot.readMessageEnd()
2231 
    if result.success is not None:
2232 
      return result.success
2233 
    if result.ex is not None:
2234 
      raise result.ex
2235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2236 
 
3064 chandransh 2237 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2238 
    """
3064 chandransh 2239 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2240 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2241 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2242 
 
94 ashish 2243 
    Parameters:
3064 chandransh 2244 
     - providerId
2245 
     - pickupDetails
304 ashish 2246 
    """
3064 chandransh 2247 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2248 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2249 
 
3064 chandransh 2250 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2251 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2252 
    args = markOrdersAsPickedUp_args()
2253 
    args.providerId = providerId
2254 
    args.pickupDetails = pickupDetails
304 ashish 2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
3064 chandransh 2259 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
3064 chandransh 2266 
    result = markOrdersAsPickedUp_result()
304 ashish 2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
3431 rajveer 2269 
    if result.success is not None:
304 ashish 2270 
      return result.success
3431 rajveer 2271 
    if result.ex is not None:
3064 chandransh 2272 
      raise result.ex
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2274 
 
3064 chandransh 2275 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2276 
    """
3064 chandransh 2277 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2278 
    the name of the receiver.
2279 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2280 
 
304 ashish 2281 
    Parameters:
3064 chandransh 2282 
     - providerId
2283 
     - deliveredOrders
304 ashish 2284 
    """
3064 chandransh 2285 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2286 
    self.recv_markOrdersAsDelivered()
304 ashish 2287 
 
3064 chandransh 2288 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2289 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2290 
    args = markOrdersAsDelivered_args()
2291 
    args.providerId = providerId
2292 
    args.deliveredOrders = deliveredOrders
304 ashish 2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
3064 chandransh 2297 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
3064 chandransh 2304 
    result = markOrdersAsDelivered_result()
304 ashish 2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
3431 rajveer 2307 
    if result.ex is not None:
3064 chandransh 2308 
      raise result.ex
304 ashish 2309 
    return
2310 
 
3064 chandransh 2311 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2312 
    """
3064 chandransh 2313 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2314 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2315 
 
3064 chandransh 2316 
    Parameters:
2317 
     - providerId
2318 
     - returnedOrders
1596 ankur.sing 2319 
    """
3064 chandransh 2320 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2321 
    self.recv_markOrdersAsFailed()
304 ashish 2322 
 
3064 chandransh 2323 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2324 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2325 
    args = markOrdersAsFailed_args()
2326 
    args.providerId = providerId
2327 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2328 
    args.write(self._oprot)
2329 
    self._oprot.writeMessageEnd()
2330 
    self._oprot.trans.flush()
2331 
 
3064 chandransh 2332 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2334 
    if mtype == TMessageType.EXCEPTION:
2335 
      x = TApplicationException()
2336 
      x.read(self._iprot)
2337 
      self._iprot.readMessageEnd()
2338 
      raise x
3064 chandransh 2339 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2340 
    result.read(self._iprot)
2341 
    self._iprot.readMessageEnd()
3431 rajveer 2342 
    if result.ex is not None:
3064 chandransh 2343 
      raise result.ex
2344 
    return
1596 ankur.sing 2345 
 
3064 chandransh 2346 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2347 
    """
3064 chandransh 2348 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2349 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2350 
 
3064 chandransh 2351 
    Parameters:
2352 
     - providerId
2353 
     - undeliveredOrders
1627 ankur.sing 2354 
    """
3064 chandransh 2355 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2356 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2357 
 
3064 chandransh 2358 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2359 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2360 
    args = updateNonDeliveryReason_args()
2361 
    args.providerId = providerId
2362 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
3064 chandransh 2367 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
3064 chandransh 2374 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
4581 phani.kuma 2377 
    if result.success is not None:
2378 
      return result.success
3431 rajveer 2379 
    if result.ex is not None:
3064 chandransh 2380 
      raise result.ex
4581 phani.kuma 2381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2382 
 
3064 chandransh 2383 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2384 
    """
3064 chandransh 2385 
    Returns the list of orders whose delivery time has passed but have not been
2386 
    delivered yet for the given provider and warehouse. To get a complete list of
2387 
    undelivered orders, pass them as -1.
2388 
    Returns an empty list if no such orders exist.
3431 rajveer 2389 
 
1886 ankur.sing 2390 
    Parameters:
3064 chandransh 2391 
     - providerId
2392 
     - warehouseId
1886 ankur.sing 2393 
    """
3064 chandransh 2394 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2395 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2396 
 
3064 chandransh 2397 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2398 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2399 
    args = getUndeliveredOrders_args()
2400 
    args.providerId = providerId
2401 
    args.warehouseId = warehouseId
1886 ankur.sing 2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
3064 chandransh 2406 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
3064 chandransh 2413 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
3431 rajveer 2416 
    if result.success is not None:
1886 ankur.sing 2417 
      return result.success
3064 chandransh 2418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2419 
 
2536 chandransh 2420 
  def toggleDOAFlag(self, orderId):
2421 
    """
2422 
    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.
2423 
    Returns the final flag status.
2424 
    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 2425 
 
2536 chandransh 2426 
    Parameters:
2427 
     - orderId
2428 
    """
2429 
    self.send_toggleDOAFlag(orderId)
2430 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2431 
 
2536 chandransh 2432 
  def send_toggleDOAFlag(self, orderId):
2433 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2434 
    args = toggleDOAFlag_args()
2435 
    args.orderId = orderId
2436 
    args.write(self._oprot)
2437 
    self._oprot.writeMessageEnd()
2438 
    self._oprot.trans.flush()
2439 
 
2440 
  def recv_toggleDOAFlag(self, ):
2441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2442 
    if mtype == TMessageType.EXCEPTION:
2443 
      x = TApplicationException()
2444 
      x.read(self._iprot)
2445 
      self._iprot.readMessageEnd()
2446 
      raise x
2447 
    result = toggleDOAFlag_result()
2448 
    result.read(self._iprot)
2449 
    self._iprot.readMessageEnd()
3431 rajveer 2450 
    if result.success is not None:
2536 chandransh 2451 
      return result.success
3431 rajveer 2452 
    if result.ex is not None:
2536 chandransh 2453 
      raise result.ex
2454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2455 
 
4454 rajveer 2456 
  def markOrderDoaRequestReceived(self, orderId):
2457 
    """
2458 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2459 
 
2460 
    Parameters:
2461 
     - orderId
2462 
    """
2463 
    self.send_markOrderDoaRequestReceived(orderId)
2464 
    return self.recv_markOrderDoaRequestReceived()
2465 
 
2466 
  def send_markOrderDoaRequestReceived(self, orderId):
2467 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2468 
    args = markOrderDoaRequestReceived_args()
2469 
    args.orderId = orderId
2470 
    args.write(self._oprot)
2471 
    self._oprot.writeMessageEnd()
2472 
    self._oprot.trans.flush()
2473 
 
2474 
  def recv_markOrderDoaRequestReceived(self, ):
2475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2476 
    if mtype == TMessageType.EXCEPTION:
2477 
      x = TApplicationException()
2478 
      x.read(self._iprot)
2479 
      self._iprot.readMessageEnd()
2480 
      raise x
2481 
    result = markOrderDoaRequestReceived_result()
2482 
    result.read(self._iprot)
2483 
    self._iprot.readMessageEnd()
2484 
    if result.success is not None:
2485 
      return result.success
2486 
    if result.ex is not None:
2487 
      raise result.ex
2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2489 
 
2490 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2491 
    """
2492 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2493 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2494 
 
2495 
    Parameters:
2496 
     - orderId
2497 
     - isAuthorized
2498 
    """
2499 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2500 
    return self.recv_markOrderDoaRequestAuthorized()
2501 
 
2502 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2503 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2504 
    args = markOrderDoaRequestAuthorized_args()
2505 
    args.orderId = orderId
2506 
    args.isAuthorized = isAuthorized
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_markOrderDoaRequestAuthorized(self, ):
2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
2518 
    result = markOrderDoaRequestAuthorized_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
2521 
    if result.success is not None:
2522 
      return result.success
2523 
    if result.ex is not None:
2524 
      raise result.ex
2525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2526 
 
4488 rajveer 2527 
  def markOrderReturnRequestReceived(self, orderId):
2528 
    """
2529 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2530 
 
2531 
    Parameters:
2532 
     - orderId
2533 
    """
2534 
    self.send_markOrderReturnRequestReceived(orderId)
2535 
    return self.recv_markOrderReturnRequestReceived()
2536 
 
2537 
  def send_markOrderReturnRequestReceived(self, orderId):
2538 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2539 
    args = markOrderReturnRequestReceived_args()
2540 
    args.orderId = orderId
2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
2545 
  def recv_markOrderReturnRequestReceived(self, ):
2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
2552 
    result = markOrderReturnRequestReceived_result()
2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
2555 
    if result.success is not None:
2556 
      return result.success
2557 
    if result.ex is not None:
2558 
      raise result.ex
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2560 
 
2561 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2562 
    """
2563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2564 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2565 
 
2566 
    Parameters:
2567 
     - orderId
2568 
     - isAuthorized
2569 
    """
2570 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2571 
    return self.recv_markOrderReturnRequestAuthorized()
2572 
 
2573 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2574 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2575 
    args = markOrderReturnRequestAuthorized_args()
2576 
    args.orderId = orderId
2577 
    args.isAuthorized = isAuthorized
2578 
    args.write(self._oprot)
2579 
    self._oprot.writeMessageEnd()
2580 
    self._oprot.trans.flush()
2581 
 
2582 
  def recv_markOrderReturnRequestAuthorized(self, ):
2583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2584 
    if mtype == TMessageType.EXCEPTION:
2585 
      x = TApplicationException()
2586 
      x.read(self._iprot)
2587 
      self._iprot.readMessageEnd()
2588 
      raise x
2589 
    result = markOrderReturnRequestAuthorized_result()
2590 
    result.read(self._iprot)
2591 
    self._iprot.readMessageEnd()
2592 
    if result.success is not None:
2593 
      return result.success
2594 
    if result.ex is not None:
2595 
      raise result.ex
2596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2597 
 
4579 rajveer 2598 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2599 
    """
2600 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2601 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2602 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2603 
    For any other status, it returns false.
2604 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2605 
 
2536 chandransh 2606 
    Parameters:
2607 
     - orderId
4579 rajveer 2608 
     - providerId
2536 chandransh 2609 
    """
4579 rajveer 2610 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2611 
    return self.recv_requestPickupNumber()
2612 
 
4579 rajveer 2613 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2614 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2615 
    args = requestPickupNumber_args()
2616 
    args.orderId = orderId
4579 rajveer 2617 
    args.providerId = providerId
2536 chandransh 2618 
    args.write(self._oprot)
2619 
    self._oprot.writeMessageEnd()
2620 
    self._oprot.trans.flush()
2621 
 
2622 
  def recv_requestPickupNumber(self, ):
2623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2624 
    if mtype == TMessageType.EXCEPTION:
2625 
      x = TApplicationException()
2626 
      x.read(self._iprot)
2627 
      self._iprot.readMessageEnd()
2628 
      raise x
2629 
    result = requestPickupNumber_result()
2630 
    result.read(self._iprot)
2631 
    self._iprot.readMessageEnd()
3431 rajveer 2632 
    if result.success is not None:
2536 chandransh 2633 
      return result.success
3431 rajveer 2634 
    if result.ex is not None:
2536 chandransh 2635 
      raise result.ex
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2637 
 
4602 rajveer 2638 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2639 
    """
4452 rajveer 2640 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2641 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2642 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2643 
    	3. Returns true
2591 chandransh 2644 
    If the order is in any other status, it returns false.
2536 chandransh 2645 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2646 
 
2536 chandransh 2647 
    Parameters:
2648 
     - orderId
2649 
     - pickupNumber
4602 rajveer 2650 
     - providerId
2536 chandransh 2651 
    """
4602 rajveer 2652 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2653 
    return self.recv_authorizePickup()
2654 
 
4602 rajveer 2655 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2656 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2657 
    args = authorizePickup_args()
2658 
    args.orderId = orderId
2659 
    args.pickupNumber = pickupNumber
4602 rajveer 2660 
    args.providerId = providerId
2536 chandransh 2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_authorizePickup(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = authorizePickup_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
3431 rajveer 2675 
    if result.success is not None:
2536 chandransh 2676 
      return result.success
3431 rajveer 2677 
    if result.ex is not None:
2536 chandransh 2678 
      raise result.ex
2679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2680 
 
2764 chandransh 2681 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2682 
    """
2683 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2684 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2685 
 
2764 chandransh 2686 
    Parameters:
2687 
     - providerId
2688 
     - pickupDetails
2689 
    """
2690 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2691 
    return self.recv_markDoasAsPickedUp()
2692 
 
2693 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2694 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2695 
    args = markDoasAsPickedUp_args()
2696 
    args.providerId = providerId
2697 
    args.pickupDetails = pickupDetails
2698 
    args.write(self._oprot)
2699 
    self._oprot.writeMessageEnd()
2700 
    self._oprot.trans.flush()
2701 
 
2702 
  def recv_markDoasAsPickedUp(self, ):
2703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2704 
    if mtype == TMessageType.EXCEPTION:
2705 
      x = TApplicationException()
2706 
      x.read(self._iprot)
2707 
      self._iprot.readMessageEnd()
2708 
      raise x
2709 
    result = markDoasAsPickedUp_result()
2710 
    result.read(self._iprot)
2711 
    self._iprot.readMessageEnd()
3431 rajveer 2712 
    if result.success is not None:
2764 chandransh 2713 
      return result.success
2714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2715 
 
4479 rajveer 2716 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2717 
    """
4452 rajveer 2718 
    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 2719 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2720 
    If the order is in any other state, it returns false.
2721 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2722 
 
2591 chandransh 2723 
    Parameters:
2724 
     - orderId
4479 rajveer 2725 
     - receiveCondition
2591 chandransh 2726 
    """
4479 rajveer 2727 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2728 
    return self.recv_receiveReturn()
2536 chandransh 2729 
 
4479 rajveer 2730 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2731 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2732 
    args = receiveReturn_args()
2591 chandransh 2733 
    args.orderId = orderId
4479 rajveer 2734 
    args.receiveCondition = receiveCondition
2591 chandransh 2735 
    args.write(self._oprot)
2736 
    self._oprot.writeMessageEnd()
2737 
    self._oprot.trans.flush()
2738 
 
2616 chandransh 2739 
  def recv_receiveReturn(self, ):
2591 chandransh 2740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2741 
    if mtype == TMessageType.EXCEPTION:
2742 
      x = TApplicationException()
2743 
      x.read(self._iprot)
2744 
      self._iprot.readMessageEnd()
2745 
      raise x
2616 chandransh 2746 
    result = receiveReturn_result()
2591 chandransh 2747 
    result.read(self._iprot)
2748 
    self._iprot.readMessageEnd()
3431 rajveer 2749 
    if result.success is not None:
2591 chandransh 2750 
      return result.success
3431 rajveer 2751 
    if result.ex is not None:
2591 chandransh 2752 
      raise result.ex
2616 chandransh 2753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2754 
 
2755 
  def validateDoa(self, orderId, isValid):
2756 
    """
4452 rajveer 2757 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2758 
    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 2759 
    If the order is in any other state, it returns false.
2760 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2761 
 
2591 chandransh 2762 
    Parameters:
2763 
     - orderId
2764 
     - isValid
2765 
    """
2766 
    self.send_validateDoa(orderId, isValid)
2767 
    return self.recv_validateDoa()
2768 
 
2769 
  def send_validateDoa(self, orderId, isValid):
2770 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2771 
    args = validateDoa_args()
2772 
    args.orderId = orderId
2773 
    args.isValid = isValid
2774 
    args.write(self._oprot)
2775 
    self._oprot.writeMessageEnd()
2776 
    self._oprot.trans.flush()
2777 
 
2778 
  def recv_validateDoa(self, ):
2779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2780 
    if mtype == TMessageType.EXCEPTION:
2781 
      x = TApplicationException()
2782 
      x.read(self._iprot)
2783 
      self._iprot.readMessageEnd()
2784 
      raise x
2785 
    result = validateDoa_result()
2786 
    result.read(self._iprot)
2787 
    self._iprot.readMessageEnd()
3431 rajveer 2788 
    if result.success is not None:
2591 chandransh 2789 
      return result.success
3431 rajveer 2790 
    if result.ex is not None:
2591 chandransh 2791 
      raise result.ex
2792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2793 
 
4495 rajveer 2794 
  def validateReturnProduct(self, orderId, isUsable):
2795 
    """
2796 
    Parameters:
2797 
     - orderId
2798 
     - isUsable
2799 
    """
2800 
    self.send_validateReturnProduct(orderId, isUsable)
2801 
    return self.recv_validateReturnProduct()
2802 
 
2803 
  def send_validateReturnProduct(self, orderId, isUsable):
2804 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2805 
    args = validateReturnProduct_args()
2806 
    args.orderId = orderId
2807 
    args.isUsable = isUsable
2808 
    args.write(self._oprot)
2809 
    self._oprot.writeMessageEnd()
2810 
    self._oprot.trans.flush()
2811 
 
2812 
  def recv_validateReturnProduct(self, ):
2813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2814 
    if mtype == TMessageType.EXCEPTION:
2815 
      x = TApplicationException()
2816 
      x.read(self._iprot)
2817 
      self._iprot.readMessageEnd()
2818 
      raise x
2819 
    result = validateReturnProduct_result()
2820 
    result.read(self._iprot)
2821 
    self._iprot.readMessageEnd()
2822 
    if result.success is not None:
2823 
      return result.success
2824 
    if result.ex is not None:
2825 
      raise result.ex
2826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2827 
 
2616 chandransh 2828 
  def reshipOrder(self, orderId):
2829 
    """
4484 rajveer 2830 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2831 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2832 
    	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 2833 
 
2834 
    If the order is in DOA_CERT_VALID state, it does the following:
2835 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2836 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2837 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2838 
 
2616 chandransh 2839 
    Returns the id of the newly created order.
3431 rajveer 2840 
 
2616 chandransh 2841 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2842 
 
2616 chandransh 2843 
    Parameters:
2844 
     - orderId
2845 
    """
2846 
    self.send_reshipOrder(orderId)
2847 
    return self.recv_reshipOrder()
2591 chandransh 2848 
 
2616 chandransh 2849 
  def send_reshipOrder(self, orderId):
2850 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2851 
    args = reshipOrder_args()
2852 
    args.orderId = orderId
2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_reshipOrder(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = reshipOrder_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
3431 rajveer 2867 
    if result.success is not None:
2616 chandransh 2868 
      return result.success
3431 rajveer 2869 
    if result.ex is not None:
2616 chandransh 2870 
      raise result.ex
2871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2872 
 
3226 chandransh 2873 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2874 
    """
4484 rajveer 2875 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2876 
    	1. Creates a refund request for batch processing.
2877 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2878 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2879 
 
2616 chandransh 2880 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2881 
    	1. Creates a refund request for batch processing.
3226 chandransh 2882 
    	2. Cancels the reservation of the item in the warehouse.
2883 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2884 
 
3226 chandransh 2885 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2886 
    	1. Cancels the reservation of the item in the warehouse.
2887 
    	2. Marks the current order as CANCELED.
2888 
 
2889 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2890 
 
2616 chandransh 2891 
    Returns True if it is successful, False otherwise.
3431 rajveer 2892 
 
2616 chandransh 2893 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2894 
 
2616 chandransh 2895 
    Parameters:
2896 
     - orderId
3226 chandransh 2897 
     - refundedBy
2898 
     - reason
2616 chandransh 2899 
    """
3226 chandransh 2900 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2901 
    return self.recv_refundOrder()
2902 
 
3226 chandransh 2903 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2904 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2905 
    args = refundOrder_args()
2906 
    args.orderId = orderId
3226 chandransh 2907 
    args.refundedBy = refundedBy
2908 
    args.reason = reason
2616 chandransh 2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_refundOrder(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = refundOrder_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
3431 rajveer 2923 
    if result.success is not None:
2616 chandransh 2924 
      return result.success
3431 rajveer 2925 
    if result.ex is not None:
2616 chandransh 2926 
      raise result.ex
2927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2928 
 
2690 chandransh 2929 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2930 
    """
2931 
    Get all return orders created between the from and to dates for the given warehouse.
2932 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2933 
 
2690 chandransh 2934 
    Parameters:
2935 
     - warehouseId
2936 
     - fromDate
2937 
     - toDate
2938 
    """
2939 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2940 
    return self.recv_getReturnOrders()
2616 chandransh 2941 
 
2690 chandransh 2942 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2943 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2944 
    args = getReturnOrders_args()
2945 
    args.warehouseId = warehouseId
2946 
    args.fromDate = fromDate
2947 
    args.toDate = toDate
2948 
    args.write(self._oprot)
2949 
    self._oprot.writeMessageEnd()
2950 
    self._oprot.trans.flush()
2951 
 
2952 
  def recv_getReturnOrders(self, ):
2953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2954 
    if mtype == TMessageType.EXCEPTION:
2955 
      x = TApplicationException()
2956 
      x.read(self._iprot)
2957 
      self._iprot.readMessageEnd()
2958 
      raise x
2959 
    result = getReturnOrders_result()
2960 
    result.read(self._iprot)
2961 
    self._iprot.readMessageEnd()
3431 rajveer 2962 
    if result.success is not None:
2690 chandransh 2963 
      return result.success
2964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2965 
 
2700 chandransh 2966 
  def getReturnOrder(self, id):
2967 
    """
2968 
    Returns the ReturnOrder corresponding to the given id.
2969 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2970 
 
2700 chandransh 2971 
    Parameters:
2972 
     - id
2973 
    """
2974 
    self.send_getReturnOrder(id)
2975 
    return self.recv_getReturnOrder()
2976 
 
2977 
  def send_getReturnOrder(self, id):
2978 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2979 
    args = getReturnOrder_args()
2980 
    args.id = id
2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_getReturnOrder(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = getReturnOrder_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
3431 rajveer 2995 
    if result.success is not None:
2700 chandransh 2996 
      return result.success
3431 rajveer 2997 
    if result.ex is not None:
2700 chandransh 2998 
      raise result.ex
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3000 
 
2690 chandransh 3001 
  def processReturn(self, returnOrderId):
3002 
    """
3003 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3004 
 
2690 chandransh 3005 
    Parameters:
3006 
     - returnOrderId
3007 
    """
3008 
    self.send_processReturn(returnOrderId)
3009 
    self.recv_processReturn()
3010 
 
3011 
  def send_processReturn(self, returnOrderId):
3012 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3013 
    args = processReturn_args()
3014 
    args.returnOrderId = returnOrderId
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_processReturn(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = processReturn_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3431 rajveer 3029 
    if result.ex is not None:
2690 chandransh 3030 
      raise result.ex
3031 
    return
3032 
 
2819 chandransh 3033 
  def createPurchaseOrder(self, warehouseId):
3034 
    """
4586 mandeep.dh 3035 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3036 
    Returns the list of PO no. of the newly created purchase order.
3037 
    Returns null if no new purchase order had to be created.
3431 rajveer 3038 
 
2819 chandransh 3039 
    Parameters:
3040 
     - warehouseId
3041 
    """
3042 
    self.send_createPurchaseOrder(warehouseId)
3043 
    return self.recv_createPurchaseOrder()
2690 chandransh 3044 
 
2819 chandransh 3045 
  def send_createPurchaseOrder(self, warehouseId):
3046 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3047 
    args = createPurchaseOrder_args()
3048 
    args.warehouseId = warehouseId
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_createPurchaseOrder(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = createPurchaseOrder_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3431 rajveer 3063 
    if result.success is not None:
2819 chandransh 3064 
      return result.success
3431 rajveer 3065 
    if result.ex is not None:
2819 chandransh 3066 
      raise result.ex
3067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3068 
 
3451 chandransh 3069 
  def updateWeight(self, orderId, weight):
3070 
    """
3071 
    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 3072 
 
3451 chandransh 3073 
    Parameters:
3074 
     - orderId
3075 
     - weight
3076 
    """
3077 
    self.send_updateWeight(orderId, weight)
3078 
    return self.recv_updateWeight()
3079 
 
3080 
  def send_updateWeight(self, orderId, weight):
3081 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3082 
    args = updateWeight_args()
3083 
    args.orderId = orderId
3084 
    args.weight = weight
3085 
    args.write(self._oprot)
3086 
    self._oprot.writeMessageEnd()
3087 
    self._oprot.trans.flush()
3088 
 
3089 
  def recv_updateWeight(self, ):
3090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3091 
    if mtype == TMessageType.EXCEPTION:
3092 
      x = TApplicationException()
3093 
      x.read(self._iprot)
3094 
      self._iprot.readMessageEnd()
3095 
      raise x
3096 
    result = updateWeight_result()
3097 
    result.read(self._iprot)
3098 
    self._iprot.readMessageEnd()
3099 
    if result.success is not None:
3100 
      return result.success
3101 
    if result.ex is not None:
3102 
      raise result.ex
3103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3104 
 
3469 chandransh 3105 
  def changeItem(self, orderId, itemId):
3106 
    """
3107 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3108 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3109 
 
3469 chandransh 3110 
    Parameters:
3111 
     - orderId
3112 
     - itemId
3113 
    """
3114 
    self.send_changeItem(orderId, itemId)
3115 
    return self.recv_changeItem()
3116 
 
3117 
  def send_changeItem(self, orderId, itemId):
3118 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3119 
    args = changeItem_args()
3120 
    args.orderId = orderId
3121 
    args.itemId = itemId
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_changeItem(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = changeItem_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    if result.ex is not None:
3139 
      raise result.ex
3140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3141 
 
3142 
  def shiftToWarehouse(self, orderId, warehouseId):
3143 
    """
3144 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3145 
 
3146 
    Parameters:
3147 
     - orderId
3148 
     - warehouseId
3149 
    """
3150 
    self.send_shiftToWarehouse(orderId, warehouseId)
3151 
    return self.recv_shiftToWarehouse()
3152 
 
3153 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3154 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3155 
    args = shiftToWarehouse_args()
3156 
    args.orderId = orderId
3157 
    args.warehouseId = warehouseId
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_shiftToWarehouse(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = shiftToWarehouse_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3172 
    if result.success is not None:
3173 
      return result.success
3174 
    if result.ex is not None:
3175 
      raise result.ex
3176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3177 
 
3986 chandransh 3178 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3179 
    """
3180 
    Adds the given delay reason to the given order.
3986 chandransh 3181 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3182 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3183 
 
3553 chandransh 3184 
    Parameters:
3185 
     - orderId
3186 
     - delayReason
3986 chandransh 3187 
     - furtherDelay
3553 chandransh 3188 
    """
3986 chandransh 3189 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3190 
    return self.recv_addDelayReason()
3191 
 
3986 chandransh 3192 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3193 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3194 
    args = addDelayReason_args()
3195 
    args.orderId = orderId
3196 
    args.delayReason = delayReason
3986 chandransh 3197 
    args.furtherDelay = furtherDelay
3553 chandransh 3198 
    args.write(self._oprot)
3199 
    self._oprot.writeMessageEnd()
3200 
    self._oprot.trans.flush()
3201 
 
3202 
  def recv_addDelayReason(self, ):
3203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3204 
    if mtype == TMessageType.EXCEPTION:
3205 
      x = TApplicationException()
3206 
      x.read(self._iprot)
3207 
      self._iprot.readMessageEnd()
3208 
      raise x
3209 
    result = addDelayReason_result()
3210 
    result.read(self._iprot)
3211 
    self._iprot.readMessageEnd()
3212 
    if result.success is not None:
3213 
      return result.success
3214 
    if result.ex is not None:
3215 
      raise result.ex
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3217 
 
3956 chandransh 3218 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3219 
    """
3220 
    Marks the COD orders with given AWB nos. as having been processed.
3221 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3222 
 
3956 chandransh 3223 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3224 
    1. There is no order corresponding to an AWB number.
3225 
    2. The captured amount for a payment exceeds the total payment.
3226 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3227 
 
3228 
    Parameters:
3229 
     - collectedAmountMap
3230 
     - xferBy
3231 
     - xferTxnId
3232 
     - xferDate
3233 
    """
3234 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3235 
    return self.recv_reconcileCodCollection()
3236 
 
3237 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3238 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3239 
    args = reconcileCodCollection_args()
3240 
    args.collectedAmountMap = collectedAmountMap
3241 
    args.xferBy = xferBy
3242 
    args.xferTxnId = xferTxnId
3243 
    args.xferDate = xferDate
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_reconcileCodCollection(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = reconcileCodCollection_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
3260 
    if result.ex is not None:
3261 
      raise result.ex
3262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3263 
 
4008 mandeep.dh 3264 
  def getTransactionsRequiringExtraProcessing(self, category):
3265 
    """
4065 mandeep.dh 3266 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3267 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3268 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3269 
 
4008 mandeep.dh 3270 
    Parameters:
3271 
     - category
3272 
    """
3273 
    self.send_getTransactionsRequiringExtraProcessing(category)
3274 
    return self.recv_getTransactionsRequiringExtraProcessing()
3275 
 
3276 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3277 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3278 
    args = getTransactionsRequiringExtraProcessing_args()
3279 
    args.category = category
3280 
    args.write(self._oprot)
3281 
    self._oprot.writeMessageEnd()
3282 
    self._oprot.trans.flush()
3283 
 
3284 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3286 
    if mtype == TMessageType.EXCEPTION:
3287 
      x = TApplicationException()
3288 
      x.read(self._iprot)
3289 
      self._iprot.readMessageEnd()
3290 
      raise x
3291 
    result = getTransactionsRequiringExtraProcessing_result()
3292 
    result.read(self._iprot)
3293 
    self._iprot.readMessageEnd()
3294 
    if result.success is not None:
3295 
      return result.success
3296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3297 
 
3298 
  def markTransactionAsProcessed(self, transactionId, category):
3299 
    """
3300 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3301 
    It essentially deletes the transaction id record for a particular
3302 
    processing type category (if present) from DB.
3303 
    This is currently used by CRM application.
4008 mandeep.dh 3304 
 
3305 
    Parameters:
3306 
     - transactionId
3307 
     - category
3308 
    """
3309 
    self.send_markTransactionAsProcessed(transactionId, category)
3310 
    self.recv_markTransactionAsProcessed()
3311 
 
3312 
  def send_markTransactionAsProcessed(self, transactionId, category):
3313 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3314 
    args = markTransactionAsProcessed_args()
3315 
    args.transactionId = transactionId
3316 
    args.category = category
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_markTransactionAsProcessed(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = markTransactionAsProcessed_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
3331 
    return
3332 
 
4018 chandransh 3333 
  def getItemWiseRiskyOrdersCount(self, ):
3334 
    """
3335 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3336 
    is defined as one whose shipping date is about to expire.
3337 
    """
3338 
    self.send_getItemWiseRiskyOrdersCount()
3339 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3340 
 
4018 chandransh 3341 
  def send_getItemWiseRiskyOrdersCount(self, ):
3342 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3343 
    args = getItemWiseRiskyOrdersCount_args()
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = getItemWiseRiskyOrdersCount_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3361 
 
4295 varun.gupt 3362 
  def getOrdersForItemIds(self, itemIds):
3363 
    """
3364 
    Returns a list of all orders which have items with given id
3365 
 
3366 
    Parameters:
3367 
     - itemIds
3368 
    """
3369 
    self.send_getOrdersForItemIds(itemIds)
3370 
    return self.recv_getOrdersForItemIds()
3371 
 
3372 
  def send_getOrdersForItemIds(self, itemIds):
3373 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3374 
    args = getOrdersForItemIds_args()
3375 
    args.itemIds = itemIds
3376 
    args.write(self._oprot)
3377 
    self._oprot.writeMessageEnd()
3378 
    self._oprot.trans.flush()
3379 
 
3380 
  def recv_getOrdersForItemIds(self, ):
3381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3382 
    if mtype == TMessageType.EXCEPTION:
3383 
      x = TApplicationException()
3384 
      x.read(self._iprot)
3385 
      self._iprot.readMessageEnd()
3386 
      raise x
3387 
    result = getOrdersForItemIds_result()
3388 
    result.read(self._iprot)
3389 
    self._iprot.readMessageEnd()
3390 
    if result.success is not None:
3391 
      return result.success
3392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3393 
 
4247 rajveer 3394 
  def markOrderCancellationRequestReceived(self, orderId):
3395 
    """
3396 
    Mark order as cancellation request received. If customer sends request of cancellation of
3397 
    a particular order, this method will be called. It will just change status of the order
3398 
    depending on its current status. It also records the previous status, so that we can move
3399 
    back to that status if cancellation request is denied.
4018 chandransh 3400 
 
4247 rajveer 3401 
    Parameters:
3402 
     - orderId
3403 
    """
3404 
    self.send_markOrderCancellationRequestReceived(orderId)
3405 
    self.recv_markOrderCancellationRequestReceived()
3406 
 
3407 
  def send_markOrderCancellationRequestReceived(self, orderId):
3408 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3409 
    args = markOrderCancellationRequestReceived_args()
3410 
    args.orderId = orderId
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_markOrderCancellationRequestReceived(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = markOrderCancellationRequestReceived_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
3425 
    if result.ex is not None:
3426 
      raise result.ex
3427 
    return
3428 
 
3429 
  def markOrderCancellationRequestConfirmed(self, orderId):
3430 
    """
3431 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3432 
    cancellation request confirmed. After this OM will be able to cancel the order.
3433 
 
3434 
    Parameters:
3435 
     - orderId
3436 
    """
3437 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3438 
    self.recv_markOrderCancellationRequestConfirmed()
3439 
 
3440 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3441 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3442 
    args = markOrderCancellationRequestConfirmed_args()
3443 
    args.orderId = orderId
3444 
    args.write(self._oprot)
3445 
    self._oprot.writeMessageEnd()
3446 
    self._oprot.trans.flush()
3447 
 
3448 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3450 
    if mtype == TMessageType.EXCEPTION:
3451 
      x = TApplicationException()
3452 
      x.read(self._iprot)
3453 
      self._iprot.readMessageEnd()
3454 
      raise x
3455 
    result = markOrderCancellationRequestConfirmed_result()
3456 
    result.read(self._iprot)
3457 
    self._iprot.readMessageEnd()
3458 
    if result.ex is not None:
3459 
      raise result.ex
3460 
    return
3461 
 
3462 
  def markOrderCancellationRequestDenied(self, orderId):
3463 
    """
3464 
    If we decide to not to cancel order, we will move the order ro previous status.
3465 
 
3466 
    Parameters:
3467 
     - orderId
3468 
    """
3469 
    self.send_markOrderCancellationRequestDenied(orderId)
3470 
    self.recv_markOrderCancellationRequestDenied()
3471 
 
3472 
  def send_markOrderCancellationRequestDenied(self, orderId):
3473 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3474 
    args = markOrderCancellationRequestDenied_args()
3475 
    args.orderId = orderId
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_markOrderCancellationRequestDenied(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = markOrderCancellationRequestDenied_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3490 
    if result.ex is not None:
3491 
      raise result.ex
3492 
    return
3493 
 
4258 rajveer 3494 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3495 
    """
4258 rajveer 3496 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3497 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3498 
 
3499 
    Parameters:
4258 rajveer 3500 
     - transactionId
4247 rajveer 3501 
    """
4258 rajveer 3502 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3503 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3504 
 
4258 rajveer 3505 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3506 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3507 
    args = markTransactionAsPaymentFlagRemoved_args()
3508 
    args.transactionId = transactionId
4247 rajveer 3509 
    args.write(self._oprot)
3510 
    self._oprot.writeMessageEnd()
3511 
    self._oprot.trans.flush()
3512 
 
4258 rajveer 3513 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3515 
    if mtype == TMessageType.EXCEPTION:
3516 
      x = TApplicationException()
3517 
      x.read(self._iprot)
3518 
      self._iprot.readMessageEnd()
3519 
      raise x
4258 rajveer 3520 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3521 
    result.read(self._iprot)
3522 
    self._iprot.readMessageEnd()
3523 
    if result.ex is not None:
3524 
      raise result.ex
3525 
    return
3526 
 
4259 anupam.sin 3527 
  def refundTransaction(self, transactionId, refundedBy, reason):
3528 
    """
3529 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3530 
    need to be cancelled
4247 rajveer 3531 
 
4259 anupam.sin 3532 
    Parameters:
3533 
     - transactionId
3534 
     - refundedBy
3535 
     - reason
3536 
    """
3537 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3538 
    self.recv_refundTransaction()
3539 
 
3540 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3541 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3542 
    args = refundTransaction_args()
3543 
    args.transactionId = transactionId
3544 
    args.refundedBy = refundedBy
3545 
    args.reason = reason
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_refundTransaction(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = refundTransaction_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    if result.ex is not None:
3561 
      raise result.ex
3562 
    return
3563 
 
4324 mandeep.dh 3564 
  def updateShipmentAddress(self, orderId, addressId):
3565 
    """
3566 
    Updates shipment address of an order. Delivery and shipping date estimates
3567 
    etc. are also updated here.
3568 
 
3569 
    Throws TransactionServiceException in case address change is not
3570 
    possible due to certain reasons such as new pincode in address is
3571 
    not serviceable etc.
3572 
 
3573 
    Parameters:
3574 
     - orderId
3575 
     - addressId
3576 
    """
3577 
    self.send_updateShipmentAddress(orderId, addressId)
3578 
    self.recv_updateShipmentAddress()
3579 
 
3580 
  def send_updateShipmentAddress(self, orderId, addressId):
3581 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3582 
    args = updateShipmentAddress_args()
3583 
    args.orderId = orderId
3584 
    args.addressId = addressId
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_updateShipmentAddress(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = updateShipmentAddress_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3599 
    if result.ex is not None:
3600 
      raise result.ex
3601 
    return
3602 
 
4285 rajveer 3603 
  def acceptOrdersForItemId(self, itemId, inventory):
3604 
    """
3605 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3606 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3607 
 
4285 rajveer 3608 
    Parameters:
3609 
     - itemId
3610 
     - inventory
3611 
    """
3612 
    self.send_acceptOrdersForItemId(itemId, inventory)
3613 
    return self.recv_acceptOrdersForItemId()
3614 
 
3615 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3616 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3617 
    args = acceptOrdersForItemId_args()
3618 
    args.itemId = itemId
3619 
    args.inventory = inventory
3620 
    args.write(self._oprot)
3621 
    self._oprot.writeMessageEnd()
3622 
    self._oprot.trans.flush()
3623 
 
3624 
  def recv_acceptOrdersForItemId(self, ):
3625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3626 
    if mtype == TMessageType.EXCEPTION:
3627 
      x = TApplicationException()
3628 
      x.read(self._iprot)
3629 
      self._iprot.readMessageEnd()
3630 
      raise x
3631 
    result = acceptOrdersForItemId_result()
3632 
    result.read(self._iprot)
3633 
    self._iprot.readMessageEnd()
3634 
    if result.success is not None:
3635 
      return result.success
3636 
    if result.ex is not None:
3637 
      raise result.ex
3638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3639 
 
4369 rajveer 3640 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3641 
    """
3642 
    Parameters:
3643 
     - vendorId
3644 
     - itemId
3645 
     - quantity
3646 
     - estimate
4369 rajveer 3647 
     - isReminder
4303 rajveer 3648 
    """
4369 rajveer 3649 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3650 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3651 
 
4369 rajveer 3652 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3653 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3654 
    args = markOrdersAsPORaised_args()
3655 
    args.vendorId = vendorId
3656 
    args.itemId = itemId
3657 
    args.quantity = quantity
3658 
    args.estimate = estimate
4369 rajveer 3659 
    args.isReminder = isReminder
4303 rajveer 3660 
    args.write(self._oprot)
3661 
    self._oprot.writeMessageEnd()
3662 
    self._oprot.trans.flush()
3663 
 
3664 
  def recv_markOrdersAsPORaised(self, ):
3665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3666 
    if mtype == TMessageType.EXCEPTION:
3667 
      x = TApplicationException()
3668 
      x.read(self._iprot)
3669 
      self._iprot.readMessageEnd()
3670 
      raise x
3671 
    result = markOrdersAsPORaised_result()
3672 
    result.read(self._iprot)
3673 
    self._iprot.readMessageEnd()
3674 
    if result.ex is not None:
3675 
      raise result.ex
3676 
    return
3677 
 
4369 rajveer 3678 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3679 
    """
3680 
    Parameters:
3681 
     - vendorId
3682 
     - itemId
3683 
     - quantity
3684 
     - estimate
4369 rajveer 3685 
     - isReminder
4303 rajveer 3686 
    """
4369 rajveer 3687 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3688 
    self.recv_markOrdersAsReversalInitiated()
3689 
 
4369 rajveer 3690 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3691 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3692 
    args = markOrdersAsReversalInitiated_args()
3693 
    args.vendorId = vendorId
3694 
    args.itemId = itemId
3695 
    args.quantity = quantity
3696 
    args.estimate = estimate
4369 rajveer 3697 
    args.isReminder = isReminder
4303 rajveer 3698 
    args.write(self._oprot)
3699 
    self._oprot.writeMessageEnd()
3700 
    self._oprot.trans.flush()
3701 
 
3702 
  def recv_markOrdersAsReversalInitiated(self, ):
3703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3704 
    if mtype == TMessageType.EXCEPTION:
3705 
      x = TApplicationException()
3706 
      x.read(self._iprot)
3707 
      self._iprot.readMessageEnd()
3708 
      raise x
3709 
    result = markOrdersAsReversalInitiated_result()
3710 
    result.read(self._iprot)
3711 
    self._iprot.readMessageEnd()
3712 
    if result.ex is not None:
3713 
      raise result.ex
3714 
    return
3715 
 
4369 rajveer 3716 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3717 
    """
3718 
    Parameters:
3719 
     - vendorId
3720 
     - itemId
3721 
     - quantity
3722 
     - estimate
4369 rajveer 3723 
     - isReminder
4303 rajveer 3724 
    """
4369 rajveer 3725 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3726 
    self.recv_markOrdersAsNotAvailabke()
3727 
 
4369 rajveer 3728 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3729 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3730 
    args = markOrdersAsNotAvailabke_args()
3731 
    args.vendorId = vendorId
3732 
    args.itemId = itemId
3733 
    args.quantity = quantity
3734 
    args.estimate = estimate
4369 rajveer 3735 
    args.isReminder = isReminder
4303 rajveer 3736 
    args.write(self._oprot)
3737 
    self._oprot.writeMessageEnd()
3738 
    self._oprot.trans.flush()
3739 
 
3740 
  def recv_markOrdersAsNotAvailabke(self, ):
3741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3742 
    if mtype == TMessageType.EXCEPTION:
3743 
      x = TApplicationException()
3744 
      x.read(self._iprot)
3745 
      self._iprot.readMessageEnd()
3746 
      raise x
3747 
    result = markOrdersAsNotAvailabke_result()
3748 
    result.read(self._iprot)
3749 
    self._iprot.readMessageEnd()
3750 
    if result.ex is not None:
3751 
      raise result.ex
3752 
    return
3753 
 
4369 rajveer 3754 
  def markOrdersAsTimeout(self, vendorId):
3755 
    """
3756 
    Parameters:
3757 
     - vendorId
3758 
    """
3759 
    self.send_markOrdersAsTimeout(vendorId)
3760 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3761 
 
4369 rajveer 3762 
  def send_markOrdersAsTimeout(self, vendorId):
3763 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3764 
    args = markOrdersAsTimeout_args()
3765 
    args.vendorId = vendorId
3766 
    args.write(self._oprot)
3767 
    self._oprot.writeMessageEnd()
3768 
    self._oprot.trans.flush()
3769 
 
3770 
  def recv_markOrdersAsTimeout(self, ):
3771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3772 
    if mtype == TMessageType.EXCEPTION:
3773 
      x = TApplicationException()
3774 
      x.read(self._iprot)
3775 
      self._iprot.readMessageEnd()
3776 
      raise x
3777 
    result = markOrdersAsTimeout_result()
3778 
    result.read(self._iprot)
3779 
    self._iprot.readMessageEnd()
3780 
    if result.success is not None:
3781 
      return result.success
3782 
    if result.ex is not None:
3783 
      raise result.ex
3784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3785 
 
4386 anupam.sin 3786 
  def getOrderForAwb(self, awb):
3787 
    """
3788 
    Returns the order corresponding to an AWB number
4369 rajveer 3789 
 
4386 anupam.sin 3790 
    Parameters:
3791 
     - awb
3792 
    """
3793 
    self.send_getOrderForAwb(awb)
3794 
    return self.recv_getOrderForAwb()
3795 
 
3796 
  def send_getOrderForAwb(self, awb):
3797 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3798 
    args = getOrderForAwb_args()
3799 
    args.awb = awb
3800 
    args.write(self._oprot)
3801 
    self._oprot.writeMessageEnd()
3802 
    self._oprot.trans.flush()
3803 
 
3804 
  def recv_getOrderForAwb(self, ):
3805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3806 
    if mtype == TMessageType.EXCEPTION:
3807 
      x = TApplicationException()
3808 
      x.read(self._iprot)
3809 
      self._iprot.readMessageEnd()
3810 
      raise x
3811 
    result = getOrderForAwb_result()
3812 
    result.read(self._iprot)
3813 
    self._iprot.readMessageEnd()
3814 
    if result.success is not None:
3815 
      return result.success
3816 
    if result.ex is not None:
3817 
      raise result.ex
3818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3819 
 
4506 phani.kuma 3820 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3821 
    """
3822 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3823 
 
4506 phani.kuma 3824 
    Parameters:
3825 
     - logistics_provider_id
3826 
     - order_status
3827 
    """
3828 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3829 
    return self.recv_getOrdersForProviderForStatus()
3830 
 
3831 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3832 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3833 
    args = getOrdersForProviderForStatus_args()
3834 
    args.logistics_provider_id = logistics_provider_id
3835 
    args.order_status = order_status
3836 
    args.write(self._oprot)
3837 
    self._oprot.writeMessageEnd()
3838 
    self._oprot.trans.flush()
3839 
 
3840 
  def recv_getOrdersForProviderForStatus(self, ):
3841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3842 
    if mtype == TMessageType.EXCEPTION:
3843 
      x = TApplicationException()
3844 
      x.read(self._iprot)
3845 
      self._iprot.readMessageEnd()
3846 
      raise x
3847 
    result = getOrdersForProviderForStatus_result()
3848 
    result.read(self._iprot)
3849 
    self._iprot.readMessageEnd()
3850 
    if result.success is not None:
3851 
      return result.success
3852 
    if result.ex is not None:
3853 
      raise result.ex
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3855 
 
4600 varun.gupt 3856 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3857 
    """
3858 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3859 
 
4600 varun.gupt 3860 
    Parameters:
3861 
     - vendorId
3862 
     - billingDateFrom
3863 
     - billingDateTo
3864 
    """
3865 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3866 
    return self.recv_getBilledOrdersForVendor()
3867 
 
3868 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3869 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3870 
    args = getBilledOrdersForVendor_args()
3871 
    args.vendorId = vendorId
3872 
    args.billingDateFrom = billingDateFrom
3873 
    args.billingDateTo = billingDateTo
3874 
    args.write(self._oprot)
3875 
    self._oprot.writeMessageEnd()
3876 
    self._oprot.trans.flush()
3877 
 
3878 
  def recv_getBilledOrdersForVendor(self, ):
3879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3880 
    if mtype == TMessageType.EXCEPTION:
3881 
      x = TApplicationException()
3882 
      x.read(self._iprot)
3883 
      self._iprot.readMessageEnd()
3884 
      raise x
3885 
    result = getBilledOrdersForVendor_result()
3886 
    result.read(self._iprot)
3887 
    self._iprot.readMessageEnd()
3888 
    if result.success is not None:
3889 
      return result.success
3890 
    if result.ex is not None:
3891 
      raise result.ex
3892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3893 
 
4607 rajveer 3894 
  def getSlippedSippingDateOrders(self, ):
3895 
    self.send_getSlippedSippingDateOrders()
3896 
    return self.recv_getSlippedSippingDateOrders()
3897 
 
3898 
  def send_getSlippedSippingDateOrders(self, ):
3899 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
3900 
    args = getSlippedSippingDateOrders_args()
3901 
    args.write(self._oprot)
3902 
    self._oprot.writeMessageEnd()
3903 
    self._oprot.trans.flush()
3904 
 
3905 
  def recv_getSlippedSippingDateOrders(self, ):
3906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3907 
    if mtype == TMessageType.EXCEPTION:
3908 
      x = TApplicationException()
3909 
      x.read(self._iprot)
3910 
      self._iprot.readMessageEnd()
3911 
      raise x
3912 
    result = getSlippedSippingDateOrders_result()
3913 
    result.read(self._iprot)
3914 
    self._iprot.readMessageEnd()
3915 
    if result.success is not None:
3916 
      return result.success
3917 
    if result.ex is not None:
3918 
      raise result.ex
3919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
3920 
 
4600 varun.gupt 3921 
  def saveBluedartSettlements(self, mapAWBAndAmount):
3922 
    """
3923 
    Parameters:
3924 
     - mapAWBAndAmount
3925 
    """
3926 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
3927 
    self.recv_saveBluedartSettlements()
3928 
 
3929 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
3930 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
3931 
    args = saveBluedartSettlements_args()
3932 
    args.mapAWBAndAmount = mapAWBAndAmount
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_saveBluedartSettlements(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = saveBluedartSettlements_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    if result.ex is not None:
3948 
      raise result.ex
3949 
    return
3950 
 
3951 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3952 
    """
3953 
    Parameters:
3954 
     - settlementDate
3955 
     - paymentGatewayId
3956 
     - paymentId
3957 
     - serviceTax
3958 
     - otherCharges
3959 
     - netCollection
3960 
    """
3961 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
3962 
    self.recv_savePaymentSettlements()
3963 
 
3964 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3965 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
3966 
    args = savePaymentSettlements_args()
3967 
    args.settlementDate = settlementDate
3968 
    args.paymentGatewayId = paymentGatewayId
3969 
    args.paymentId = paymentId
3970 
    args.serviceTax = serviceTax
3971 
    args.otherCharges = otherCharges
3972 
    args.netCollection = netCollection
3973 
    args.write(self._oprot)
3974 
    self._oprot.writeMessageEnd()
3975 
    self._oprot.trans.flush()
3976 
 
3977 
  def recv_savePaymentSettlements(self, ):
3978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3979 
    if mtype == TMessageType.EXCEPTION:
3980 
      x = TApplicationException()
3981 
      x.read(self._iprot)
3982 
      self._iprot.readMessageEnd()
3983 
      raise x
3984 
    result = savePaymentSettlements_result()
3985 
    result.read(self._iprot)
3986 
    self._iprot.readMessageEnd()
3987 
    if result.ex is not None:
3988 
      raise result.ex
3989 
    return
3990 
 
3991 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3992 
    """
3993 
    Parameters:
3994 
     - settlementId
3995 
     - settlementDate
3996 
     - transactionDateFrom
3997 
     - transactionDateTo
3998 
     - amount
3999 
    """
4000 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4001 
    self.recv_saveEBSSettlementSummary()
4002 
 
4003 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4004 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4005 
    args = saveEBSSettlementSummary_args()
4006 
    args.settlementId = settlementId
4007 
    args.settlementDate = settlementDate
4008 
    args.transactionDateFrom = transactionDateFrom
4009 
    args.transactionDateTo = transactionDateTo
4010 
    args.amount = amount
4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4015 
  def recv_saveEBSSettlementSummary(self, ):
4016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4017 
    if mtype == TMessageType.EXCEPTION:
4018 
      x = TApplicationException()
4019 
      x.read(self._iprot)
4020 
      self._iprot.readMessageEnd()
4021 
      raise x
4022 
    result = saveEBSSettlementSummary_result()
4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
4025 
    if result.ex is not None:
4026 
      raise result.ex
4027 
    return
4028 
 
4029 
  def getSettlementForPaymentId(self, paymentId):
4030 
    """
4031 
    Parameters:
4032 
     - paymentId
4033 
    """
4034 
    self.send_getSettlementForPaymentId(paymentId)
4035 
    return self.recv_getSettlementForPaymentId()
4036 
 
4037 
  def send_getSettlementForPaymentId(self, paymentId):
4038 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4039 
    args = getSettlementForPaymentId_args()
4040 
    args.paymentId = paymentId
4041 
    args.write(self._oprot)
4042 
    self._oprot.writeMessageEnd()
4043 
    self._oprot.trans.flush()
4044 
 
4045 
  def recv_getSettlementForPaymentId(self, ):
4046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4047 
    if mtype == TMessageType.EXCEPTION:
4048 
      x = TApplicationException()
4049 
      x.read(self._iprot)
4050 
      self._iprot.readMessageEnd()
4051 
      raise x
4052 
    result = getSettlementForPaymentId_result()
4053 
    result.read(self._iprot)
4054 
    self._iprot.readMessageEnd()
4055 
    if result.success is not None:
4056 
      return result.success
4057 
    if result.ex is not None:
4058 
      raise result.ex
4059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4060 
 
4061 
  def getEBSSettlementSummaries(self, ):
4062 
    self.send_getEBSSettlementSummaries()
4063 
    return self.recv_getEBSSettlementSummaries()
4064 
 
4065 
  def send_getEBSSettlementSummaries(self, ):
4066 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4067 
    args = getEBSSettlementSummaries_args()
4068 
    args.write(self._oprot)
4069 
    self._oprot.writeMessageEnd()
4070 
    self._oprot.trans.flush()
4071 
 
4072 
  def recv_getEBSSettlementSummaries(self, ):
4073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4074 
    if mtype == TMessageType.EXCEPTION:
4075 
      x = TApplicationException()
4076 
      x.read(self._iprot)
4077 
      self._iprot.readMessageEnd()
4078 
      raise x
4079 
    result = getEBSSettlementSummaries_result()
4080 
    result.read(self._iprot)
4081 
    self._iprot.readMessageEnd()
4082 
    if result.success is not None:
4083 
      return result.success
4084 
    if result.ex is not None:
4085 
      raise result.ex
4086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4087 
 
4088 
  def markEBSSettlementUploaded(self, settlementId):
4089 
    """
4090 
    Parameters:
4091 
     - settlementId
4092 
    """
4093 
    self.send_markEBSSettlementUploaded(settlementId)
4094 
    self.recv_markEBSSettlementUploaded()
4095 
 
4096 
  def send_markEBSSettlementUploaded(self, settlementId):
4097 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4098 
    args = markEBSSettlementUploaded_args()
4099 
    args.settlementId = settlementId
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_markEBSSettlementUploaded(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = markEBSSettlementUploaded_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.ex is not None:
4115 
      raise result.ex
4116 
    return
4117 
 
4118 
  def getEBSSettlementDate(self, settlementId):
4119 
    """
4120 
    Parameters:
4121 
     - settlementId
4122 
    """
4123 
    self.send_getEBSSettlementDate(settlementId)
4124 
    return self.recv_getEBSSettlementDate()
4125 
 
4126 
  def send_getEBSSettlementDate(self, settlementId):
4127 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4128 
    args = getEBSSettlementDate_args()
4129 
    args.settlementId = settlementId
4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_getEBSSettlementDate(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = getEBSSettlementDate_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
4144 
    if result.success is not None:
4145 
      return result.success
4146 
    if result.ex is not None:
4147 
      raise result.ex
4148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4149 
 
4150 
 
3376 rajveer 4151 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4152 
  def __init__(self, handler):
3376 rajveer 4153 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4154 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4155 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4156 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4157 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4158 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4159 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4160 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4161 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4162 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4163 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4164 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4165 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4166 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4167 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4168 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4169 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4170 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4171 
    self._processMap["createOrder"] = Processor.process_createOrder
4172 
    self._processMap["getOrder"] = Processor.process_getOrder
4173 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4174 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4175 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4176 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4177 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4178 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4179 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4180 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4181 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4182 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4183 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4184 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4185 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4186 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4187 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4188 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4189 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4190 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4191 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4192 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4193 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4194 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4195 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4196 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4197 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4198 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4199 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4200 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4201 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4202 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4203 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4204 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4205 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4206 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4207 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4208 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4209 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4210 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4211 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4212 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4213 
    self._processMap["changeItem"] = Processor.process_changeItem
4214 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4215 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4216 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4217 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4218 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4219 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4220 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4221 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4222 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4223 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4224 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4225 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4226 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4227 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4228 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4229 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4230 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4231 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 4232 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4233 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4234 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4235 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4600 varun.gupt 4236 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4237 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4238 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4239 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4240 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4241 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4242 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4243 
 
4244 
  def process(self, iprot, oprot):
4245 
    (name, type, seqid) = iprot.readMessageBegin()
4246 
    if name not in self._processMap:
4247 
      iprot.skip(TType.STRUCT)
4248 
      iprot.readMessageEnd()
4249 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4250 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4251 
      x.write(oprot)
4252 
      oprot.writeMessageEnd()
4253 
      oprot.trans.flush()
4254 
      return
4255 
    else:
4256 
      self._processMap[name](self, seqid, iprot, oprot)
4257 
    return True
4258 
 
4259 
  def process_createTransaction(self, seqid, iprot, oprot):
4260 
    args = createTransaction_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = createTransaction_result()
4264 
    try:
132 ashish 4265 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4266 
    except TransactionServiceException, ex:
4267 
      result.ex = ex
4268 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_getTransaction(self, seqid, iprot, oprot):
4274 
    args = getTransaction_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = getTransaction_result()
4278 
    try:
4279 
      result.success = self._handler.getTransaction(args.id)
4280 
    except TransactionServiceException, ex:
4281 
      result.ex = ex
4282 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
4287 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4288 
    args = getTransactionsForCustomer_args()
4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4291 
    result = getTransactionsForCustomer_result()
4292 
    try:
4293 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4294 
    except TransactionServiceException, ex:
4295 
      result.ex = ex
4296 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
132 ashish 4301 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4302 
    args = getTransactionsForShoppingCartId_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = getTransactionsForShoppingCartId_result()
4306 
    try:
4307 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4308 
    except TransactionServiceException, ex:
4309 
      result.ex = ex
4310 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4314 
 
94 ashish 4315 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4316 
    args = getTransactionStatus_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = getTransactionStatus_result()
4320 
    try:
4321 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4322 
    except TransactionServiceException, ex:
4323 
      result.ex = ex
4324 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
4328 
 
4329 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4330 
    args = changeTransactionStatus_args()
4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
4333 
    result = changeTransactionStatus_result()
4334 
    try:
4335 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4336 
    except TransactionServiceException, ex:
4337 
      result.ex = ex
4338 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
1398 varun.gupt 4343 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4344 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
1398 varun.gupt 4347 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4348 
    try:
1398 varun.gupt 4349 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4350 
    except TransactionServiceException, ex:
4351 
      result.ex = ex
1398 varun.gupt 4352 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4356 
 
483 rajveer 4357 
  def process_getAllOrders(self, seqid, iprot, oprot):
4358 
    args = getAllOrders_args()
94 ashish 4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
483 rajveer 4361 
    result = getAllOrders_result()
94 ashish 4362 
    try:
483 rajveer 4363 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4364 
    except TransactionServiceException, ex:
4365 
      result.ex = ex
483 rajveer 4366 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
4370 
 
4133 chandransh 4371 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4372 
    args = getOrdersInBatch_args()
4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
4375 
    result = getOrdersInBatch_result()
4376 
    try:
4377 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4378 
    except TransactionServiceException, ex:
4379 
      result.ex = ex
4380 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4385 
  def process_getOrderCount(self, seqid, iprot, oprot):
4386 
    args = getOrderCount_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = getOrderCount_result()
4390 
    try:
4391 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4392 
    except TransactionServiceException, ex:
4393 
      result.ex = ex
4394 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
4398 
 
999 varun.gupt 4399 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4400 
    args = getOrdersByBillingDate_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = getOrdersByBillingDate_result()
4404 
    try:
4405 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4406 
    except TransactionServiceException, ex:
4407 
      result.ex = ex
4408 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4412 
 
3427 chandransh 4413 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4414 
    args = getOrdersByShippingDate_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = getOrdersByShippingDate_result()
4418 
    try:
3451 chandransh 4419 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4420 
    except TransactionServiceException, ex:
4421 
      result.ex = ex
4422 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4423 
    result.write(oprot)
4424 
    oprot.writeMessageEnd()
4425 
    oprot.trans.flush()
4426 
 
1382 varun.gupt 4427 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4428 
    args = getReturnableOrdersForCustomer_args()
4429 
    args.read(iprot)
4430 
    iprot.readMessageEnd()
4431 
    result = getReturnableOrdersForCustomer_result()
4432 
    try:
4433 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4434 
    except TransactionServiceException, ex:
4435 
      result.ex = ex
4436 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
4440 
 
4441 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4442 
    args = getCancellableOrdersForCustomer_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = getCancellableOrdersForCustomer_result()
4446 
    try:
4447 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4448 
    except TransactionServiceException, ex:
4449 
      result.ex = ex
4450 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
4454 
 
483 rajveer 4455 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4456 
    args = changeOrderStatus_args()
94 ashish 4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
483 rajveer 4459 
    result = changeOrderStatus_result()
94 ashish 4460 
    try:
483 rajveer 4461 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4462 
    except TransactionServiceException, ex:
4463 
      result.ex = ex
483 rajveer 4464 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4465 
    result.write(oprot)
4466 
    oprot.writeMessageEnd()
4467 
    oprot.trans.flush()
4468 
 
483 rajveer 4469 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4470 
    args = getOrdersForTransaction_args()
94 ashish 4471 
    args.read(iprot)
4472 
    iprot.readMessageEnd()
483 rajveer 4473 
    result = getOrdersForTransaction_result()
94 ashish 4474 
    try:
1528 ankur.sing 4475 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4476 
    except TransactionServiceException, ex:
4477 
      result.ex = ex
483 rajveer 4478 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
483 rajveer 4483 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4484 
    args = getOrdersForCustomer_args()
94 ashish 4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
483 rajveer 4487 
    result = getOrdersForCustomer_result()
94 ashish 4488 
    try:
3014 chandransh 4489 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4490 
    except TransactionServiceException, ex:
4491 
      result.ex = ex
483 rajveer 4492 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4493 
    result.write(oprot)
4494 
    oprot.writeMessageEnd()
4495 
    oprot.trans.flush()
4496 
 
483 rajveer 4497 
  def process_createOrder(self, seqid, iprot, oprot):
4498 
    args = createOrder_args()
94 ashish 4499 
    args.read(iprot)
4500 
    iprot.readMessageEnd()
483 rajveer 4501 
    result = createOrder_result()
94 ashish 4502 
    try:
483 rajveer 4503 
      result.success = self._handler.createOrder(args.order)
94 ashish 4504 
    except TransactionServiceException, ex:
4505 
      result.ex = ex
483 rajveer 4506 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4507 
    result.write(oprot)
4508 
    oprot.writeMessageEnd()
4509 
    oprot.trans.flush()
4510 
 
483 rajveer 4511 
  def process_getOrder(self, seqid, iprot, oprot):
4512 
    args = getOrder_args()
94 ashish 4513 
    args.read(iprot)
4514 
    iprot.readMessageEnd()
483 rajveer 4515 
    result = getOrder_result()
94 ashish 4516 
    try:
483 rajveer 4517 
      result.success = self._handler.getOrder(args.id)
94 ashish 4518 
    except TransactionServiceException, ex:
4519 
      result.ex = ex
483 rajveer 4520 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4521 
    result.write(oprot)
4522 
    oprot.writeMessageEnd()
4523 
    oprot.trans.flush()
4524 
 
483 rajveer 4525 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4526 
    args = getLineItemsForOrder_args()
94 ashish 4527 
    args.read(iprot)
4528 
    iprot.readMessageEnd()
483 rajveer 4529 
    result = getLineItemsForOrder_result()
94 ashish 4530 
    try:
483 rajveer 4531 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4532 
    except TransactionServiceException, ex:
4533 
      result.ex = ex
483 rajveer 4534 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4535 
    result.write(oprot)
4536 
    oprot.writeMessageEnd()
4537 
    oprot.trans.flush()
4538 
 
1528 ankur.sing 4539 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4540 
    args = getOrderForCustomer_args()
4541 
    args.read(iprot)
4542 
    iprot.readMessageEnd()
4543 
    result = getOrderForCustomer_result()
4544 
    try:
4545 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4546 
    except TransactionServiceException, ex:
4547 
      result.ex = ex
4548 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4549 
    result.write(oprot)
4550 
    oprot.writeMessageEnd()
4551 
    oprot.trans.flush()
4552 
 
3064 chandransh 4553 
  def process_getAlerts(self, seqid, iprot, oprot):
4554 
    args = getAlerts_args()
4555 
    args.read(iprot)
4556 
    iprot.readMessageEnd()
4557 
    result = getAlerts_result()
4444 rajveer 4558 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4559 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4560 
    result.write(oprot)
4561 
    oprot.writeMessageEnd()
4562 
    oprot.trans.flush()
4563 
 
4394 rajveer 4564 
  def process_addAlert(self, seqid, iprot, oprot):
4565 
    args = addAlert_args()
3064 chandransh 4566 
    args.read(iprot)
4567 
    iprot.readMessageEnd()
4394 rajveer 4568 
    result = addAlert_result()
4444 rajveer 4569 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4570 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
4444 rajveer 4575 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4576 
    args = markAlertsAsSeen_args()
4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
4579 
    result = markAlertsAsSeen_result()
4580 
    self._handler.markAlertsAsSeen(args.warehouseId)
4581 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
3064 chandransh 4586 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4587 
    args = getValidOrderCount_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = getValidOrderCount_result()
4591 
    result.success = self._handler.getValidOrderCount()
4592 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4596 
 
4597 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4598 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
4601 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4602 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4603 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
4608 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4609 
    args = getValidOrdersAmountRange_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = getValidOrdersAmountRange_result()
4613 
    result.success = self._handler.getValidOrdersAmountRange()
4614 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4615 
    result.write(oprot)
4616 
    oprot.writeMessageEnd()
4617 
    oprot.trans.flush()
4618 
 
4619 
  def process_getValidOrders(self, seqid, iprot, oprot):
4620 
    args = getValidOrders_args()
4621 
    args.read(iprot)
4622 
    iprot.readMessageEnd()
4623 
    result = getValidOrders_result()
4624 
    result.success = self._handler.getValidOrders(args.limit)
4625 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4626 
    result.write(oprot)
4627 
    oprot.writeMessageEnd()
4628 
    oprot.trans.flush()
4629 
 
1220 chandransh 4630 
  def process_batchOrders(self, seqid, iprot, oprot):
4631 
    args = batchOrders_args()
4632 
    args.read(iprot)
4633 
    iprot.readMessageEnd()
4634 
    result = batchOrders_result()
4635 
    try:
4636 
      result.success = self._handler.batchOrders(args.warehouseId)
4637 
    except TransactionServiceException, ex:
4638 
      result.ex = ex
4639 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
1208 chandransh 4644 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4645 
    args = markOrderAsOutOfStock_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = markOrderAsOutOfStock_result()
4649 
    try:
4650 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4651 
    except TransactionServiceException, ex:
4652 
      result.ex = ex
4653 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4654 
    result.write(oprot)
4655 
    oprot.writeMessageEnd()
4656 
    oprot.trans.flush()
4657 
 
3064 chandransh 4658 
  def process_verifyOrder(self, seqid, iprot, oprot):
4659 
    args = verifyOrder_args()
759 chandransh 4660 
    args.read(iprot)
4661 
    iprot.readMessageEnd()
3064 chandransh 4662 
    result = verifyOrder_result()
759 chandransh 4663 
    try:
3064 chandransh 4664 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4665 
    except TransactionServiceException, ex:
4666 
      result.ex = ex
3064 chandransh 4667 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4668 
    result.write(oprot)
4669 
    oprot.writeMessageEnd()
4670 
    oprot.trans.flush()
4671 
 
3064 chandransh 4672 
  def process_acceptOrder(self, seqid, iprot, oprot):
4673 
    args = acceptOrder_args()
1113 chandransh 4674 
    args.read(iprot)
4675 
    iprot.readMessageEnd()
3064 chandransh 4676 
    result = acceptOrder_result()
1113 chandransh 4677 
    try:
3064 chandransh 4678 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4679 
    except TransactionServiceException, ex:
4680 
      result.ex = ex
3064 chandransh 4681 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4682 
    result.write(oprot)
4683 
    oprot.writeMessageEnd()
4684 
    oprot.trans.flush()
4685 
 
3064 chandransh 4686 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4687 
    args = addBillingDetails_args()
1135 chandransh 4688 
    args.read(iprot)
4689 
    iprot.readMessageEnd()
3064 chandransh 4690 
    result = addBillingDetails_result()
1135 chandransh 4691 
    try:
4283 anupam.sin 4692 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.imeiNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4693 
    except TransactionServiceException, ex:
4694 
      result.ex = ex
3064 chandransh 4695 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4696 
    result.write(oprot)
4697 
    oprot.writeMessageEnd()
4698 
    oprot.trans.flush()
4699 
 
4579 rajveer 4700 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4701 
    args = addInvoiceNumber_args()
4702 
    args.read(iprot)
4703 
    iprot.readMessageEnd()
4704 
    result = addInvoiceNumber_result()
4705 
    try:
4706 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4707 
    except TransactionServiceException, ex:
4708 
      result.ex = ex
4709 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
3064 chandransh 4714 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4715 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
3064 chandransh 4718 
    result = markOrdersAsManifested_result()
4719 
    try:
4720 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4721 
    except TransactionServiceException, ex:
4722 
      result.ex = ex
4723 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4724 
    result.write(oprot)
4725 
    oprot.writeMessageEnd()
4726 
    oprot.trans.flush()
4727 
 
4410 rajveer 4728 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4729 
    args = markOrdersAsShippedFromWarehouse_args()
4730 
    args.read(iprot)
4731 
    iprot.readMessageEnd()
4732 
    result = markOrdersAsShippedFromWarehouse_result()
4733 
    try:
4734 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4735 
    except TransactionServiceException, ex:
4736 
      result.ex = ex
4737 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
3064 chandransh 4742 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4743 
    args = markOrdersAsPickedUp_args()
304 ashish 4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
3064 chandransh 4746 
    result = markOrdersAsPickedUp_result()
4747 
    try:
4748 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4749 
    except TransactionServiceException, ex:
4750 
      result.ex = ex
4751 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4752 
    result.write(oprot)
4753 
    oprot.writeMessageEnd()
4754 
    oprot.trans.flush()
94 ashish 4755 
 
3064 chandransh 4756 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4757 
    args = markOrdersAsDelivered_args()
304 ashish 4758 
    args.read(iprot)
4759 
    iprot.readMessageEnd()
3064 chandransh 4760 
    result = markOrdersAsDelivered_result()
4761 
    try:
4762 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4763 
    except TransactionServiceException, ex:
4764 
      result.ex = ex
4765 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
3064 chandransh 4770 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4771 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
3064 chandransh 4774 
    result = markOrdersAsFailed_result()
4775 
    try:
4776 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4777 
    except TransactionServiceException, ex:
4778 
      result.ex = ex
4779 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
304 ashish 4783 
 
3064 chandransh 4784 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4785 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
3064 chandransh 4788 
    result = updateNonDeliveryReason_result()
4789 
    try:
4581 phani.kuma 4790 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4791 
    except TransactionServiceException, ex:
4792 
      result.ex = ex
4793 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4794 
    result.write(oprot)
4795 
    oprot.writeMessageEnd()
4796 
    oprot.trans.flush()
1596 ankur.sing 4797 
 
3064 chandransh 4798 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4799 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4800 
    args.read(iprot)
4801 
    iprot.readMessageEnd()
3064 chandransh 4802 
    result = getUndeliveredOrders_result()
4803 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4804 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4805 
    result.write(oprot)
4806 
    oprot.writeMessageEnd()
4807 
    oprot.trans.flush()
4808 
 
2536 chandransh 4809 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4810 
    args = toggleDOAFlag_args()
4811 
    args.read(iprot)
4812 
    iprot.readMessageEnd()
4813 
    result = toggleDOAFlag_result()
4814 
    try:
4815 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4816 
    except TransactionServiceException, ex:
4817 
      result.ex = ex
4818 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4819 
    result.write(oprot)
4820 
    oprot.writeMessageEnd()
4821 
    oprot.trans.flush()
1886 ankur.sing 4822 
 
4454 rajveer 4823 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4824 
    args = markOrderDoaRequestReceived_args()
4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4827 
    result = markOrderDoaRequestReceived_result()
4828 
    try:
4829 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4830 
    except TransactionServiceException, ex:
4831 
      result.ex = ex
4832 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4833 
    result.write(oprot)
4834 
    oprot.writeMessageEnd()
4835 
    oprot.trans.flush()
4836 
 
4837 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4838 
    args = markOrderDoaRequestAuthorized_args()
4839 
    args.read(iprot)
4840 
    iprot.readMessageEnd()
4841 
    result = markOrderDoaRequestAuthorized_result()
4842 
    try:
4843 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4844 
    except TransactionServiceException, ex:
4845 
      result.ex = ex
4846 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4847 
    result.write(oprot)
4848 
    oprot.writeMessageEnd()
4849 
    oprot.trans.flush()
4850 
 
4488 rajveer 4851 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4852 
    args = markOrderReturnRequestReceived_args()
4853 
    args.read(iprot)
4854 
    iprot.readMessageEnd()
4855 
    result = markOrderReturnRequestReceived_result()
4856 
    try:
4857 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4858 
    except TransactionServiceException, ex:
4859 
      result.ex = ex
4860 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4861 
    result.write(oprot)
4862 
    oprot.writeMessageEnd()
4863 
    oprot.trans.flush()
4864 
 
4865 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4866 
    args = markOrderReturnRequestAuthorized_args()
4867 
    args.read(iprot)
4868 
    iprot.readMessageEnd()
4869 
    result = markOrderReturnRequestAuthorized_result()
4870 
    try:
4871 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4872 
    except TransactionServiceException, ex:
4873 
      result.ex = ex
4874 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4875 
    result.write(oprot)
4876 
    oprot.writeMessageEnd()
4877 
    oprot.trans.flush()
4878 
 
2536 chandransh 4879 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4880 
    args = requestPickupNumber_args()
4881 
    args.read(iprot)
4882 
    iprot.readMessageEnd()
4883 
    result = requestPickupNumber_result()
4884 
    try:
4579 rajveer 4885 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4886 
    except TransactionServiceException, ex:
4887 
      result.ex = ex
4888 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4889 
    result.write(oprot)
4890 
    oprot.writeMessageEnd()
4891 
    oprot.trans.flush()
4892 
 
4893 
  def process_authorizePickup(self, seqid, iprot, oprot):
4894 
    args = authorizePickup_args()
4895 
    args.read(iprot)
4896 
    iprot.readMessageEnd()
4897 
    result = authorizePickup_result()
4898 
    try:
4602 rajveer 4899 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 4900 
    except TransactionServiceException, ex:
4901 
      result.ex = ex
4902 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
2764 chandransh 4907 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4908 
    args = markDoasAsPickedUp_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = markDoasAsPickedUp_result()
4912 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4913 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
4917 
 
2616 chandransh 4918 
  def process_receiveReturn(self, seqid, iprot, oprot):
4919 
    args = receiveReturn_args()
2591 chandransh 4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
2616 chandransh 4922 
    result = receiveReturn_result()
2591 chandransh 4923 
    try:
4479 rajveer 4924 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4925 
    except TransactionServiceException, ex:
4926 
      result.ex = ex
2616 chandransh 4927 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
2536 chandransh 4931 
 
2591 chandransh 4932 
  def process_validateDoa(self, seqid, iprot, oprot):
4933 
    args = validateDoa_args()
4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
4936 
    result = validateDoa_result()
4937 
    try:
4938 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4939 
    except TransactionServiceException, ex:
4940 
      result.ex = ex
4941 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4942 
    result.write(oprot)
4943 
    oprot.writeMessageEnd()
4944 
    oprot.trans.flush()
4945 
 
4495 rajveer 4946 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4947 
    args = validateReturnProduct_args()
4948 
    args.read(iprot)
4949 
    iprot.readMessageEnd()
4950 
    result = validateReturnProduct_result()
4951 
    try:
4952 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4953 
    except TransactionServiceException, ex:
4954 
      result.ex = ex
4955 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4956 
    result.write(oprot)
4957 
    oprot.writeMessageEnd()
4958 
    oprot.trans.flush()
4959 
 
2616 chandransh 4960 
  def process_reshipOrder(self, seqid, iprot, oprot):
4961 
    args = reshipOrder_args()
4962 
    args.read(iprot)
4963 
    iprot.readMessageEnd()
4964 
    result = reshipOrder_result()
4965 
    try:
4966 
      result.success = self._handler.reshipOrder(args.orderId)
4967 
    except TransactionServiceException, ex:
4968 
      result.ex = ex
4969 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4970 
    result.write(oprot)
4971 
    oprot.writeMessageEnd()
4972 
    oprot.trans.flush()
2591 chandransh 4973 
 
2616 chandransh 4974 
  def process_refundOrder(self, seqid, iprot, oprot):
4975 
    args = refundOrder_args()
4976 
    args.read(iprot)
4977 
    iprot.readMessageEnd()
4978 
    result = refundOrder_result()
4979 
    try:
3226 chandransh 4980 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4981 
    except TransactionServiceException, ex:
4982 
      result.ex = ex
4983 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4984 
    result.write(oprot)
4985 
    oprot.writeMessageEnd()
4986 
    oprot.trans.flush()
4987 
 
2690 chandransh 4988 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4989 
    args = getReturnOrders_args()
4990 
    args.read(iprot)
4991 
    iprot.readMessageEnd()
4992 
    result = getReturnOrders_result()
4993 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4994 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4995 
    result.write(oprot)
4996 
    oprot.writeMessageEnd()
4997 
    oprot.trans.flush()
2616 chandransh 4998 
 
2700 chandransh 4999 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5000 
    args = getReturnOrder_args()
5001 
    args.read(iprot)
5002 
    iprot.readMessageEnd()
5003 
    result = getReturnOrder_result()
5004 
    try:
5005 
      result.success = self._handler.getReturnOrder(args.id)
5006 
    except TransactionServiceException, ex:
5007 
      result.ex = ex
5008 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5009 
    result.write(oprot)
5010 
    oprot.writeMessageEnd()
5011 
    oprot.trans.flush()
5012 
 
2690 chandransh 5013 
  def process_processReturn(self, seqid, iprot, oprot):
5014 
    args = processReturn_args()
5015 
    args.read(iprot)
5016 
    iprot.readMessageEnd()
5017 
    result = processReturn_result()
5018 
    try:
5019 
      self._handler.processReturn(args.returnOrderId)
5020 
    except TransactionServiceException, ex:
5021 
      result.ex = ex
5022 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5023 
    result.write(oprot)
5024 
    oprot.writeMessageEnd()
5025 
    oprot.trans.flush()
5026 
 
2819 chandransh 5027 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5028 
    args = createPurchaseOrder_args()
5029 
    args.read(iprot)
5030 
    iprot.readMessageEnd()
5031 
    result = createPurchaseOrder_result()
5032 
    try:
5033 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5034 
    except TransactionServiceException, ex:
5035 
      result.ex = ex
5036 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
2690 chandransh 5040 
 
3451 chandransh 5041 
  def process_updateWeight(self, seqid, iprot, oprot):
5042 
    args = updateWeight_args()
5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
5045 
    result = updateWeight_result()
5046 
    try:
5047 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5048 
    except TransactionServiceException, ex:
5049 
      result.ex = ex
5050 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5051 
    result.write(oprot)
5052 
    oprot.writeMessageEnd()
5053 
    oprot.trans.flush()
2819 chandransh 5054 
 
3469 chandransh 5055 
  def process_changeItem(self, seqid, iprot, oprot):
5056 
    args = changeItem_args()
5057 
    args.read(iprot)
5058 
    iprot.readMessageEnd()
5059 
    result = changeItem_result()
5060 
    try:
5061 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5062 
    except TransactionServiceException, ex:
5063 
      result.ex = ex
5064 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5065 
    result.write(oprot)
5066 
    oprot.writeMessageEnd()
5067 
    oprot.trans.flush()
3451 chandransh 5068 
 
3469 chandransh 5069 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5070 
    args = shiftToWarehouse_args()
5071 
    args.read(iprot)
5072 
    iprot.readMessageEnd()
5073 
    result = shiftToWarehouse_result()
5074 
    try:
5075 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5076 
    except TransactionServiceException, ex:
5077 
      result.ex = ex
5078 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5079 
    result.write(oprot)
5080 
    oprot.writeMessageEnd()
5081 
    oprot.trans.flush()
5082 
 
3553 chandransh 5083 
  def process_addDelayReason(self, seqid, iprot, oprot):
5084 
    args = addDelayReason_args()
5085 
    args.read(iprot)
5086 
    iprot.readMessageEnd()
5087 
    result = addDelayReason_result()
5088 
    try:
3986 chandransh 5089 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 5090 
    except TransactionServiceException, ex:
5091 
      result.ex = ex
5092 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5093 
    result.write(oprot)
5094 
    oprot.writeMessageEnd()
5095 
    oprot.trans.flush()
3469 chandransh 5096 
 
3956 chandransh 5097 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5098 
    args = reconcileCodCollection_args()
5099 
    args.read(iprot)
5100 
    iprot.readMessageEnd()
5101 
    result = reconcileCodCollection_result()
5102 
    try:
5103 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5104 
    except TransactionServiceException, ex:
5105 
      result.ex = ex
5106 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5107 
    result.write(oprot)
5108 
    oprot.writeMessageEnd()
5109 
    oprot.trans.flush()
3553 chandransh 5110 
 
4008 mandeep.dh 5111 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5112 
    args = getTransactionsRequiringExtraProcessing_args()
5113 
    args.read(iprot)
5114 
    iprot.readMessageEnd()
5115 
    result = getTransactionsRequiringExtraProcessing_result()
5116 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5117 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
3956 chandransh 5121 
 
4008 mandeep.dh 5122 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5123 
    args = markTransactionAsProcessed_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = markTransactionAsProcessed_result()
5127 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5128 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
4018 chandransh 5133 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5134 
    args = getItemWiseRiskyOrdersCount_args()
5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
5137 
    result = getItemWiseRiskyOrdersCount_result()
5138 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5139 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
4008 mandeep.dh 5143 
 
4295 varun.gupt 5144 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5145 
    args = getOrdersForItemIds_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = getOrdersForItemIds_result()
5149 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5150 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
5154 
 
4247 rajveer 5155 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5156 
    args = markOrderCancellationRequestReceived_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = markOrderCancellationRequestReceived_result()
5160 
    try:
5161 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5162 
    except TransactionServiceException, ex:
5163 
      result.ex = ex
5164 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5165 
    result.write(oprot)
5166 
    oprot.writeMessageEnd()
5167 
    oprot.trans.flush()
4018 chandransh 5168 
 
4247 rajveer 5169 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5170 
    args = markOrderCancellationRequestConfirmed_args()
5171 
    args.read(iprot)
5172 
    iprot.readMessageEnd()
5173 
    result = markOrderCancellationRequestConfirmed_result()
5174 
    try:
5175 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5176 
    except TransactionServiceException, ex:
5177 
      result.ex = ex
5178 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5179 
    result.write(oprot)
5180 
    oprot.writeMessageEnd()
5181 
    oprot.trans.flush()
5182 
 
5183 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5184 
    args = markOrderCancellationRequestDenied_args()
5185 
    args.read(iprot)
5186 
    iprot.readMessageEnd()
5187 
    result = markOrderCancellationRequestDenied_result()
5188 
    try:
5189 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5190 
    except TransactionServiceException, ex:
5191 
      result.ex = ex
5192 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
4258 rajveer 5197 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5198 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
4258 rajveer 5201 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5202 
    try:
4258 rajveer 5203 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5204 
    except TransactionServiceException, ex:
5205 
      result.ex = ex
4258 rajveer 5206 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5207 
    result.write(oprot)
5208 
    oprot.writeMessageEnd()
5209 
    oprot.trans.flush()
5210 
 
4259 anupam.sin 5211 
  def process_refundTransaction(self, seqid, iprot, oprot):
5212 
    args = refundTransaction_args()
5213 
    args.read(iprot)
5214 
    iprot.readMessageEnd()
5215 
    result = refundTransaction_result()
5216 
    try:
5217 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5218 
    except TransactionServiceException, ex:
5219 
      result.ex = ex
5220 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5221 
    result.write(oprot)
5222 
    oprot.writeMessageEnd()
5223 
    oprot.trans.flush()
4247 rajveer 5224 
 
4324 mandeep.dh 5225 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5226 
    args = updateShipmentAddress_args()
5227 
    args.read(iprot)
5228 
    iprot.readMessageEnd()
5229 
    result = updateShipmentAddress_result()
5230 
    try:
5231 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5232 
    except TransactionServiceException, ex:
5233 
      result.ex = ex
5234 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
5238 
 
4285 rajveer 5239 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5240 
    args = acceptOrdersForItemId_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = acceptOrdersForItemId_result()
5244 
    try:
5245 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5246 
    except TransactionServiceException, ex:
5247 
      result.ex = ex
5248 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
4259 anupam.sin 5252 
 
4303 rajveer 5253 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5254 
    args = markOrdersAsPORaised_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = markOrdersAsPORaised_result()
5258 
    try:
4369 rajveer 5259 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5260 
    except TransactionServiceException, ex:
5261 
      result.ex = ex
5262 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5263 
    result.write(oprot)
5264 
    oprot.writeMessageEnd()
5265 
    oprot.trans.flush()
4285 rajveer 5266 
 
4303 rajveer 5267 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5268 
    args = markOrdersAsReversalInitiated_args()
5269 
    args.read(iprot)
5270 
    iprot.readMessageEnd()
5271 
    result = markOrdersAsReversalInitiated_result()
5272 
    try:
4369 rajveer 5273 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5274 
    except TransactionServiceException, ex:
5275 
      result.ex = ex
5276 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
5281 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5282 
    args = markOrdersAsNotAvailabke_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = markOrdersAsNotAvailabke_result()
5286 
    try:
4369 rajveer 5287 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5288 
    except TransactionServiceException, ex:
5289 
      result.ex = ex
5290 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5291 
    result.write(oprot)
5292 
    oprot.writeMessageEnd()
5293 
    oprot.trans.flush()
5294 
 
4369 rajveer 5295 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5296 
    args = markOrdersAsTimeout_args()
5297 
    args.read(iprot)
5298 
    iprot.readMessageEnd()
5299 
    result = markOrdersAsTimeout_result()
5300 
    try:
5301 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5302 
    except TransactionServiceException, ex:
5303 
      result.ex = ex
5304 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5305 
    result.write(oprot)
5306 
    oprot.writeMessageEnd()
5307 
    oprot.trans.flush()
4303 rajveer 5308 
 
4386 anupam.sin 5309 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5310 
    args = getOrderForAwb_args()
5311 
    args.read(iprot)
5312 
    iprot.readMessageEnd()
5313 
    result = getOrderForAwb_result()
5314 
    try:
5315 
      result.success = self._handler.getOrderForAwb(args.awb)
5316 
    except TransactionServiceException, ex:
5317 
      result.ex = ex
5318 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5319 
    result.write(oprot)
5320 
    oprot.writeMessageEnd()
5321 
    oprot.trans.flush()
4369 rajveer 5322 
 
4506 phani.kuma 5323 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5324 
    args = getOrdersForProviderForStatus_args()
5325 
    args.read(iprot)
5326 
    iprot.readMessageEnd()
5327 
    result = getOrdersForProviderForStatus_result()
5328 
    try:
5329 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5330 
    except TransactionServiceException, ex:
5331 
      result.ex = ex
5332 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
4386 anupam.sin 5336 
 
4600 varun.gupt 5337 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5338 
    args = getBilledOrdersForVendor_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = getBilledOrdersForVendor_result()
5342 
    try:
5343 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5344 
    except TransactionServiceException, ex:
5345 
      result.ex = ex
5346 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
4506 phani.kuma 5350 
 
4607 rajveer 5351 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5352 
    args = getSlippedSippingDateOrders_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = getSlippedSippingDateOrders_result()
5356 
    try:
5357 
      result.success = self._handler.getSlippedSippingDateOrders()
5358 
    except TransactionServiceException, ex:
5359 
      result.ex = ex
5360 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5361 
    result.write(oprot)
5362 
    oprot.writeMessageEnd()
5363 
    oprot.trans.flush()
5364 
 
4600 varun.gupt 5365 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5366 
    args = saveBluedartSettlements_args()
5367 
    args.read(iprot)
5368 
    iprot.readMessageEnd()
5369 
    result = saveBluedartSettlements_result()
5370 
    try:
5371 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5372 
    except TransactionServiceException, ex:
5373 
      result.ex = ex
5374 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5375 
    result.write(oprot)
5376 
    oprot.writeMessageEnd()
5377 
    oprot.trans.flush()
5378 
 
5379 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5380 
    args = savePaymentSettlements_args()
5381 
    args.read(iprot)
5382 
    iprot.readMessageEnd()
5383 
    result = savePaymentSettlements_result()
5384 
    try:
5385 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5386 
    except TransactionServiceException, ex:
5387 
      result.ex = ex
5388 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
5392 
 
5393 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5394 
    args = saveEBSSettlementSummary_args()
5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
5397 
    result = saveEBSSettlementSummary_result()
5398 
    try:
5399 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5400 
    except TransactionServiceException, ex:
5401 
      result.ex = ex
5402 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5403 
    result.write(oprot)
5404 
    oprot.writeMessageEnd()
5405 
    oprot.trans.flush()
5406 
 
5407 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5408 
    args = getSettlementForPaymentId_args()
5409 
    args.read(iprot)
5410 
    iprot.readMessageEnd()
5411 
    result = getSettlementForPaymentId_result()
5412 
    try:
5413 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5414 
    except TransactionServiceException, ex:
5415 
      result.ex = ex
5416 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5417 
    result.write(oprot)
5418 
    oprot.writeMessageEnd()
5419 
    oprot.trans.flush()
5420 
 
5421 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5422 
    args = getEBSSettlementSummaries_args()
5423 
    args.read(iprot)
5424 
    iprot.readMessageEnd()
5425 
    result = getEBSSettlementSummaries_result()
5426 
    try:
5427 
      result.success = self._handler.getEBSSettlementSummaries()
5428 
    except TransactionServiceException, ex:
5429 
      result.ex = ex
5430 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5431 
    result.write(oprot)
5432 
    oprot.writeMessageEnd()
5433 
    oprot.trans.flush()
5434 
 
5435 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5436 
    args = markEBSSettlementUploaded_args()
5437 
    args.read(iprot)
5438 
    iprot.readMessageEnd()
5439 
    result = markEBSSettlementUploaded_result()
5440 
    try:
5441 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5442 
    except TransactionServiceException, ex:
5443 
      result.ex = ex
5444 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5445 
    result.write(oprot)
5446 
    oprot.writeMessageEnd()
5447 
    oprot.trans.flush()
5448 
 
5449 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5450 
    args = getEBSSettlementDate_args()
5451 
    args.read(iprot)
5452 
    iprot.readMessageEnd()
5453 
    result = getEBSSettlementDate_result()
5454 
    try:
5455 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5456 
    except TransactionServiceException, ex:
5457 
      result.ex = ex
5458 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5459 
    result.write(oprot)
5460 
    oprot.writeMessageEnd()
5461 
    oprot.trans.flush()
5462 
 
5463 
 
94 ashish 5464 
# HELPER FUNCTIONS AND STRUCTURES
5465 
 
5466 
class createTransaction_args:
5467 
  """
5468 
  Attributes:
5469 
   - transaction
5470 
  """
5471 
 
5472 
  thrift_spec = (
5473 
    None, # 0
5474 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5475 
  )
5476 
 
5477 
  def __init__(self, transaction=None,):
5478 
    self.transaction = transaction
5479 
 
5480 
  def read(self, iprot):
5481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5483 
      return
5484 
    iprot.readStructBegin()
5485 
    while True:
5486 
      (fname, ftype, fid) = iprot.readFieldBegin()
5487 
      if ftype == TType.STOP:
5488 
        break
5489 
      if fid == 1:
5490 
        if ftype == TType.STRUCT:
5491 
          self.transaction = Transaction()
5492 
          self.transaction.read(iprot)
5493 
        else:
5494 
          iprot.skip(ftype)
5495 
      else:
5496 
        iprot.skip(ftype)
5497 
      iprot.readFieldEnd()
5498 
    iprot.readStructEnd()
5499 
 
5500 
  def write(self, oprot):
5501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5503 
      return
5504 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5505 
    if self.transaction is not None:
94 ashish 5506 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5507 
      self.transaction.write(oprot)
5508 
      oprot.writeFieldEnd()
5509 
    oprot.writeFieldStop()
5510 
    oprot.writeStructEnd()
5511 
 
3431 rajveer 5512 
  def validate(self):
5513 
    return
5514 
 
5515 
 
94 ashish 5516 
  def __repr__(self):
5517 
    L = ['%s=%r' % (key, value)
5518 
      for key, value in self.__dict__.iteritems()]
5519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5520 
 
5521 
  def __eq__(self, other):
5522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5523 
 
5524 
  def __ne__(self, other):
5525 
    return not (self == other)
5526 
 
5527 
class createTransaction_result:
5528 
  """
5529 
  Attributes:
132 ashish 5530 
   - success
94 ashish 5531 
   - ex
5532 
  """
5533 
 
5534 
  thrift_spec = (
132 ashish 5535 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5537 
  )
5538 
 
132 ashish 5539 
  def __init__(self, success=None, ex=None,):
5540 
    self.success = success
94 ashish 5541 
    self.ex = ex
5542 
 
5543 
  def read(self, iprot):
5544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5546 
      return
5547 
    iprot.readStructBegin()
5548 
    while True:
5549 
      (fname, ftype, fid) = iprot.readFieldBegin()
5550 
      if ftype == TType.STOP:
5551 
        break
132 ashish 5552 
      if fid == 0:
5553 
        if ftype == TType.I64:
5554 
          self.success = iprot.readI64();
5555 
        else:
5556 
          iprot.skip(ftype)
5557 
      elif fid == 1:
94 ashish 5558 
        if ftype == TType.STRUCT:
5559 
          self.ex = TransactionServiceException()
5560 
          self.ex.read(iprot)
5561 
        else:
5562 
          iprot.skip(ftype)
5563 
      else:
5564 
        iprot.skip(ftype)
5565 
      iprot.readFieldEnd()
5566 
    iprot.readStructEnd()
5567 
 
5568 
  def write(self, oprot):
5569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5571 
      return
5572 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5573 
    if self.success is not None:
132 ashish 5574 
      oprot.writeFieldBegin('success', TType.I64, 0)
5575 
      oprot.writeI64(self.success)
5576 
      oprot.writeFieldEnd()
3431 rajveer 5577 
    if self.ex is not None:
94 ashish 5578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5579 
      self.ex.write(oprot)
5580 
      oprot.writeFieldEnd()
5581 
    oprot.writeFieldStop()
5582 
    oprot.writeStructEnd()
5583 
 
3431 rajveer 5584 
  def validate(self):
5585 
    return
5586 
 
5587 
 
94 ashish 5588 
  def __repr__(self):
5589 
    L = ['%s=%r' % (key, value)
5590 
      for key, value in self.__dict__.iteritems()]
5591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5592 
 
5593 
  def __eq__(self, other):
5594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5595 
 
5596 
  def __ne__(self, other):
5597 
    return not (self == other)
5598 
 
5599 
class getTransaction_args:
5600 
  """
5601 
  Attributes:
5602 
   - id
5603 
  """
5604 
 
5605 
  thrift_spec = (
5606 
    None, # 0
5607 
    (1, TType.I64, 'id', None, None, ), # 1
5608 
  )
5609 
 
5610 
  def __init__(self, id=None,):
5611 
    self.id = id
5612 
 
5613 
  def read(self, iprot):
5614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5616 
      return
5617 
    iprot.readStructBegin()
5618 
    while True:
5619 
      (fname, ftype, fid) = iprot.readFieldBegin()
5620 
      if ftype == TType.STOP:
5621 
        break
5622 
      if fid == 1:
5623 
        if ftype == TType.I64:
5624 
          self.id = iprot.readI64();
5625 
        else:
5626 
          iprot.skip(ftype)
5627 
      else:
5628 
        iprot.skip(ftype)
5629 
      iprot.readFieldEnd()
5630 
    iprot.readStructEnd()
5631 
 
5632 
  def write(self, oprot):
5633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5635 
      return
5636 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5637 
    if self.id is not None:
94 ashish 5638 
      oprot.writeFieldBegin('id', TType.I64, 1)
5639 
      oprot.writeI64(self.id)
5640 
      oprot.writeFieldEnd()
5641 
    oprot.writeFieldStop()
5642 
    oprot.writeStructEnd()
5643 
 
3431 rajveer 5644 
  def validate(self):
5645 
    return
5646 
 
5647 
 
94 ashish 5648 
  def __repr__(self):
5649 
    L = ['%s=%r' % (key, value)
5650 
      for key, value in self.__dict__.iteritems()]
5651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5652 
 
5653 
  def __eq__(self, other):
5654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5655 
 
5656 
  def __ne__(self, other):
5657 
    return not (self == other)
5658 
 
5659 
class getTransaction_result:
5660 
  """
5661 
  Attributes:
5662 
   - success
5663 
   - ex
5664 
  """
5665 
 
5666 
  thrift_spec = (
5667 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5669 
  )
5670 
 
5671 
  def __init__(self, success=None, ex=None,):
5672 
    self.success = success
5673 
    self.ex = ex
5674 
 
5675 
  def read(self, iprot):
5676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5678 
      return
5679 
    iprot.readStructBegin()
5680 
    while True:
5681 
      (fname, ftype, fid) = iprot.readFieldBegin()
5682 
      if ftype == TType.STOP:
5683 
        break
5684 
      if fid == 0:
5685 
        if ftype == TType.STRUCT:
5686 
          self.success = Transaction()
5687 
          self.success.read(iprot)
5688 
        else:
5689 
          iprot.skip(ftype)
5690 
      elif fid == 1:
5691 
        if ftype == TType.STRUCT:
5692 
          self.ex = TransactionServiceException()
5693 
          self.ex.read(iprot)
5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      else:
5697 
        iprot.skip(ftype)
5698 
      iprot.readFieldEnd()
5699 
    iprot.readStructEnd()
5700 
 
5701 
  def write(self, oprot):
5702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5704 
      return
5705 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5706 
    if self.success is not None:
94 ashish 5707 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5708 
      self.success.write(oprot)
5709 
      oprot.writeFieldEnd()
3431 rajveer 5710 
    if self.ex is not None:
94 ashish 5711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5712 
      self.ex.write(oprot)
5713 
      oprot.writeFieldEnd()
5714 
    oprot.writeFieldStop()
5715 
    oprot.writeStructEnd()
5716 
 
3431 rajveer 5717 
  def validate(self):
5718 
    return
5719 
 
5720 
 
94 ashish 5721 
  def __repr__(self):
5722 
    L = ['%s=%r' % (key, value)
5723 
      for key, value in self.__dict__.iteritems()]
5724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5725 
 
5726 
  def __eq__(self, other):
5727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5728 
 
5729 
  def __ne__(self, other):
5730 
    return not (self == other)
5731 
 
5732 
class getTransactionsForCustomer_args:
5733 
  """
5734 
  Attributes:
5735 
   - customerId
5736 
   - from_date
5737 
   - to_date
5738 
   - status
5739 
  """
5740 
 
5741 
  thrift_spec = (
5742 
    None, # 0
5743 
    (1, TType.I64, 'customerId', None, None, ), # 1
5744 
    (2, TType.I64, 'from_date', None, None, ), # 2
5745 
    (3, TType.I64, 'to_date', None, None, ), # 3
5746 
    (4, TType.I32, 'status', None, None, ), # 4
5747 
  )
5748 
 
5749 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5750 
    self.customerId = customerId
5751 
    self.from_date = from_date
5752 
    self.to_date = to_date
5753 
    self.status = status
5754 
 
5755 
  def read(self, iprot):
5756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5758 
      return
5759 
    iprot.readStructBegin()
5760 
    while True:
5761 
      (fname, ftype, fid) = iprot.readFieldBegin()
5762 
      if ftype == TType.STOP:
5763 
        break
5764 
      if fid == 1:
5765 
        if ftype == TType.I64:
5766 
          self.customerId = iprot.readI64();
5767 
        else:
5768 
          iprot.skip(ftype)
5769 
      elif fid == 2:
5770 
        if ftype == TType.I64:
5771 
          self.from_date = iprot.readI64();
5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      elif fid == 3:
5775 
        if ftype == TType.I64:
5776 
          self.to_date = iprot.readI64();
5777 
        else:
5778 
          iprot.skip(ftype)
5779 
      elif fid == 4:
5780 
        if ftype == TType.I32:
5781 
          self.status = iprot.readI32();
5782 
        else:
5783 
          iprot.skip(ftype)
5784 
      else:
5785 
        iprot.skip(ftype)
5786 
      iprot.readFieldEnd()
5787 
    iprot.readStructEnd()
5788 
 
5789 
  def write(self, oprot):
5790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5792 
      return
5793 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5794 
    if self.customerId is not None:
94 ashish 5795 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5796 
      oprot.writeI64(self.customerId)
5797 
      oprot.writeFieldEnd()
3431 rajveer 5798 
    if self.from_date is not None:
94 ashish 5799 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5800 
      oprot.writeI64(self.from_date)
5801 
      oprot.writeFieldEnd()
3431 rajveer 5802 
    if self.to_date is not None:
94 ashish 5803 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5804 
      oprot.writeI64(self.to_date)
5805 
      oprot.writeFieldEnd()
3431 rajveer 5806 
    if self.status is not None:
94 ashish 5807 
      oprot.writeFieldBegin('status', TType.I32, 4)
5808 
      oprot.writeI32(self.status)
5809 
      oprot.writeFieldEnd()
5810 
    oprot.writeFieldStop()
5811 
    oprot.writeStructEnd()
5812 
 
3431 rajveer 5813 
  def validate(self):
5814 
    return
5815 
 
5816 
 
94 ashish 5817 
  def __repr__(self):
5818 
    L = ['%s=%r' % (key, value)
5819 
      for key, value in self.__dict__.iteritems()]
5820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5821 
 
5822 
  def __eq__(self, other):
5823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5824 
 
5825 
  def __ne__(self, other):
5826 
    return not (self == other)
5827 
 
5828 
class getTransactionsForCustomer_result:
5829 
  """
5830 
  Attributes:
5831 
   - success
5832 
   - ex
5833 
  """
5834 
 
5835 
  thrift_spec = (
5836 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5838 
  )
5839 
 
5840 
  def __init__(self, success=None, ex=None,):
5841 
    self.success = success
5842 
    self.ex = ex
5843 
 
5844 
  def read(self, iprot):
5845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5847 
      return
5848 
    iprot.readStructBegin()
5849 
    while True:
5850 
      (fname, ftype, fid) = iprot.readFieldBegin()
5851 
      if ftype == TType.STOP:
5852 
        break
5853 
      if fid == 0:
5854 
        if ftype == TType.LIST:
5855 
          self.success = []
685 chandransh 5856 
          (_etype17, _size14) = iprot.readListBegin()
5857 
          for _i18 in xrange(_size14):
5858 
            _elem19 = Transaction()
5859 
            _elem19.read(iprot)
5860 
            self.success.append(_elem19)
94 ashish 5861 
          iprot.readListEnd()
5862 
        else:
5863 
          iprot.skip(ftype)
5864 
      elif fid == 1:
5865 
        if ftype == TType.STRUCT:
5866 
          self.ex = TransactionServiceException()
5867 
          self.ex.read(iprot)
5868 
        else:
5869 
          iprot.skip(ftype)
5870 
      else:
5871 
        iprot.skip(ftype)
5872 
      iprot.readFieldEnd()
5873 
    iprot.readStructEnd()
5874 
 
5875 
  def write(self, oprot):
5876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5878 
      return
5879 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5880 
    if self.success is not None:
94 ashish 5881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5882 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5883 
      for iter20 in self.success:
5884 
        iter20.write(oprot)
94 ashish 5885 
      oprot.writeListEnd()
5886 
      oprot.writeFieldEnd()
3431 rajveer 5887 
    if self.ex is not None:
94 ashish 5888 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5889 
      self.ex.write(oprot)
5890 
      oprot.writeFieldEnd()
5891 
    oprot.writeFieldStop()
5892 
    oprot.writeStructEnd()
5893 
 
3431 rajveer 5894 
  def validate(self):
5895 
    return
5896 
 
5897 
 
94 ashish 5898 
  def __repr__(self):
5899 
    L = ['%s=%r' % (key, value)
5900 
      for key, value in self.__dict__.iteritems()]
5901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5902 
 
5903 
  def __eq__(self, other):
5904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5905 
 
5906 
  def __ne__(self, other):
5907 
    return not (self == other)
5908 
 
132 ashish 5909 
class getTransactionsForShoppingCartId_args:
5910 
  """
5911 
  Attributes:
5912 
   - shoppingCartId
5913 
  """
5914 
 
5915 
  thrift_spec = (
5916 
    None, # 0
5917 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5918 
  )
5919 
 
5920 
  def __init__(self, shoppingCartId=None,):
5921 
    self.shoppingCartId = shoppingCartId
5922 
 
5923 
  def read(self, iprot):
5924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5926 
      return
5927 
    iprot.readStructBegin()
5928 
    while True:
5929 
      (fname, ftype, fid) = iprot.readFieldBegin()
5930 
      if ftype == TType.STOP:
5931 
        break
5932 
      if fid == 1:
5933 
        if ftype == TType.I64:
5934 
          self.shoppingCartId = iprot.readI64();
5935 
        else:
5936 
          iprot.skip(ftype)
5937 
      else:
5938 
        iprot.skip(ftype)
5939 
      iprot.readFieldEnd()
5940 
    iprot.readStructEnd()
5941 
 
5942 
  def write(self, oprot):
5943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5945 
      return
5946 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5947 
    if self.shoppingCartId is not None:
132 ashish 5948 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5949 
      oprot.writeI64(self.shoppingCartId)
5950 
      oprot.writeFieldEnd()
5951 
    oprot.writeFieldStop()
5952 
    oprot.writeStructEnd()
5953 
 
3431 rajveer 5954 
  def validate(self):
5955 
    return
5956 
 
5957 
 
132 ashish 5958 
  def __repr__(self):
5959 
    L = ['%s=%r' % (key, value)
5960 
      for key, value in self.__dict__.iteritems()]
5961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5962 
 
5963 
  def __eq__(self, other):
5964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5965 
 
5966 
  def __ne__(self, other):
5967 
    return not (self == other)
5968 
 
5969 
class getTransactionsForShoppingCartId_result:
5970 
  """
5971 
  Attributes:
5972 
   - success
5973 
   - ex
5974 
  """
5975 
 
5976 
  thrift_spec = (
5977 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5978 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5979 
  )
5980 
 
5981 
  def __init__(self, success=None, ex=None,):
5982 
    self.success = success
5983 
    self.ex = ex
5984 
 
5985 
  def read(self, iprot):
5986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5988 
      return
5989 
    iprot.readStructBegin()
5990 
    while True:
5991 
      (fname, ftype, fid) = iprot.readFieldBegin()
5992 
      if ftype == TType.STOP:
5993 
        break
5994 
      if fid == 0:
5995 
        if ftype == TType.LIST:
5996 
          self.success = []
685 chandransh 5997 
          (_etype24, _size21) = iprot.readListBegin()
5998 
          for _i25 in xrange(_size21):
5999 
            _elem26 = Transaction()
6000 
            _elem26.read(iprot)
6001 
            self.success.append(_elem26)
132 ashish 6002 
          iprot.readListEnd()
6003 
        else:
6004 
          iprot.skip(ftype)
6005 
      elif fid == 1:
6006 
        if ftype == TType.STRUCT:
6007 
          self.ex = TransactionServiceException()
6008 
          self.ex.read(iprot)
6009 
        else:
6010 
          iprot.skip(ftype)
6011 
      else:
6012 
        iprot.skip(ftype)
6013 
      iprot.readFieldEnd()
6014 
    iprot.readStructEnd()
6015 
 
6016 
  def write(self, oprot):
6017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6019 
      return
6020 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6021 
    if self.success is not None:
132 ashish 6022 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6023 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6024 
      for iter27 in self.success:
6025 
        iter27.write(oprot)
132 ashish 6026 
      oprot.writeListEnd()
6027 
      oprot.writeFieldEnd()
3431 rajveer 6028 
    if self.ex is not None:
132 ashish 6029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6030 
      self.ex.write(oprot)
6031 
      oprot.writeFieldEnd()
6032 
    oprot.writeFieldStop()
6033 
    oprot.writeStructEnd()
6034 
 
3431 rajveer 6035 
  def validate(self):
6036 
    return
6037 
 
6038 
 
132 ashish 6039 
  def __repr__(self):
6040 
    L = ['%s=%r' % (key, value)
6041 
      for key, value in self.__dict__.iteritems()]
6042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6043 
 
6044 
  def __eq__(self, other):
6045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6046 
 
6047 
  def __ne__(self, other):
6048 
    return not (self == other)
6049 
 
94 ashish 6050 
class getTransactionStatus_args:
6051 
  """
6052 
  Attributes:
6053 
   - transactionId
6054 
  """
6055 
 
6056 
  thrift_spec = (
6057 
    None, # 0
6058 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6059 
  )
6060 
 
6061 
  def __init__(self, transactionId=None,):
6062 
    self.transactionId = transactionId
6063 
 
6064 
  def read(self, iprot):
6065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6067 
      return
6068 
    iprot.readStructBegin()
6069 
    while True:
6070 
      (fname, ftype, fid) = iprot.readFieldBegin()
6071 
      if ftype == TType.STOP:
6072 
        break
6073 
      if fid == 1:
6074 
        if ftype == TType.I64:
6075 
          self.transactionId = iprot.readI64();
6076 
        else:
6077 
          iprot.skip(ftype)
6078 
      else:
6079 
        iprot.skip(ftype)
6080 
      iprot.readFieldEnd()
6081 
    iprot.readStructEnd()
6082 
 
6083 
  def write(self, oprot):
6084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6086 
      return
6087 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6088 
    if self.transactionId is not None:
94 ashish 6089 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6090 
      oprot.writeI64(self.transactionId)
6091 
      oprot.writeFieldEnd()
6092 
    oprot.writeFieldStop()
6093 
    oprot.writeStructEnd()
6094 
 
3431 rajveer 6095 
  def validate(self):
6096 
    return
6097 
 
6098 
 
94 ashish 6099 
  def __repr__(self):
6100 
    L = ['%s=%r' % (key, value)
6101 
      for key, value in self.__dict__.iteritems()]
6102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6103 
 
6104 
  def __eq__(self, other):
6105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6106 
 
6107 
  def __ne__(self, other):
6108 
    return not (self == other)
6109 
 
6110 
class getTransactionStatus_result:
6111 
  """
6112 
  Attributes:
6113 
   - success
6114 
   - ex
6115 
  """
6116 
 
6117 
  thrift_spec = (
6118 
    (0, TType.I32, 'success', None, None, ), # 0
6119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6120 
  )
6121 
 
6122 
  def __init__(self, success=None, ex=None,):
6123 
    self.success = success
6124 
    self.ex = ex
6125 
 
6126 
  def read(self, iprot):
6127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6129 
      return
6130 
    iprot.readStructBegin()
6131 
    while True:
6132 
      (fname, ftype, fid) = iprot.readFieldBegin()
6133 
      if ftype == TType.STOP:
6134 
        break
6135 
      if fid == 0:
6136 
        if ftype == TType.I32:
6137 
          self.success = iprot.readI32();
6138 
        else:
6139 
          iprot.skip(ftype)
6140 
      elif fid == 1:
6141 
        if ftype == TType.STRUCT:
6142 
          self.ex = TransactionServiceException()
6143 
          self.ex.read(iprot)
6144 
        else:
6145 
          iprot.skip(ftype)
6146 
      else:
6147 
        iprot.skip(ftype)
6148 
      iprot.readFieldEnd()
6149 
    iprot.readStructEnd()
6150 
 
6151 
  def write(self, oprot):
6152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6154 
      return
6155 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6156 
    if self.success is not None:
94 ashish 6157 
      oprot.writeFieldBegin('success', TType.I32, 0)
6158 
      oprot.writeI32(self.success)
6159 
      oprot.writeFieldEnd()
3431 rajveer 6160 
    if self.ex is not None:
94 ashish 6161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6162 
      self.ex.write(oprot)
6163 
      oprot.writeFieldEnd()
6164 
    oprot.writeFieldStop()
6165 
    oprot.writeStructEnd()
6166 
 
3431 rajveer 6167 
  def validate(self):
6168 
    return
6169 
 
6170 
 
94 ashish 6171 
  def __repr__(self):
6172 
    L = ['%s=%r' % (key, value)
6173 
      for key, value in self.__dict__.iteritems()]
6174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6175 
 
6176 
  def __eq__(self, other):
6177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6178 
 
6179 
  def __ne__(self, other):
6180 
    return not (self == other)
6181 
 
6182 
class changeTransactionStatus_args:
6183 
  """
6184 
  Attributes:
6185 
   - transactionId
6186 
   - status
6187 
   - description
6188 
  """
6189 
 
6190 
  thrift_spec = (
6191 
    None, # 0
6192 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6193 
    (2, TType.I32, 'status', None, None, ), # 2
6194 
    (3, TType.STRING, 'description', None, None, ), # 3
6195 
  )
6196 
 
6197 
  def __init__(self, transactionId=None, status=None, description=None,):
6198 
    self.transactionId = transactionId
6199 
    self.status = status
6200 
    self.description = description
6201 
 
6202 
  def read(self, iprot):
6203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6205 
      return
6206 
    iprot.readStructBegin()
6207 
    while True:
6208 
      (fname, ftype, fid) = iprot.readFieldBegin()
6209 
      if ftype == TType.STOP:
6210 
        break
6211 
      if fid == 1:
6212 
        if ftype == TType.I64:
6213 
          self.transactionId = iprot.readI64();
6214 
        else:
6215 
          iprot.skip(ftype)
6216 
      elif fid == 2:
6217 
        if ftype == TType.I32:
6218 
          self.status = iprot.readI32();
6219 
        else:
6220 
          iprot.skip(ftype)
6221 
      elif fid == 3:
6222 
        if ftype == TType.STRING:
6223 
          self.description = iprot.readString();
6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      else:
6227 
        iprot.skip(ftype)
6228 
      iprot.readFieldEnd()
6229 
    iprot.readStructEnd()
6230 
 
6231 
  def write(self, oprot):
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6234 
      return
6235 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6236 
    if self.transactionId is not None:
94 ashish 6237 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6238 
      oprot.writeI64(self.transactionId)
6239 
      oprot.writeFieldEnd()
3431 rajveer 6240 
    if self.status is not None:
94 ashish 6241 
      oprot.writeFieldBegin('status', TType.I32, 2)
6242 
      oprot.writeI32(self.status)
6243 
      oprot.writeFieldEnd()
3431 rajveer 6244 
    if self.description is not None:
94 ashish 6245 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6246 
      oprot.writeString(self.description)
6247 
      oprot.writeFieldEnd()
6248 
    oprot.writeFieldStop()
6249 
    oprot.writeStructEnd()
6250 
 
3431 rajveer 6251 
  def validate(self):
6252 
    return
6253 
 
6254 
 
94 ashish 6255 
  def __repr__(self):
6256 
    L = ['%s=%r' % (key, value)
6257 
      for key, value in self.__dict__.iteritems()]
6258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6259 
 
6260 
  def __eq__(self, other):
6261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6262 
 
6263 
  def __ne__(self, other):
6264 
    return not (self == other)
6265 
 
6266 
class changeTransactionStatus_result:
6267 
  """
6268 
  Attributes:
6269 
   - success
6270 
   - ex
6271 
  """
6272 
 
6273 
  thrift_spec = (
6274 
    (0, TType.BOOL, 'success', None, None, ), # 0
6275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6276 
  )
6277 
 
6278 
  def __init__(self, success=None, ex=None,):
6279 
    self.success = success
6280 
    self.ex = ex
6281 
 
6282 
  def read(self, iprot):
6283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6285 
      return
6286 
    iprot.readStructBegin()
6287 
    while True:
6288 
      (fname, ftype, fid) = iprot.readFieldBegin()
6289 
      if ftype == TType.STOP:
6290 
        break
6291 
      if fid == 0:
6292 
        if ftype == TType.BOOL:
6293 
          self.success = iprot.readBool();
6294 
        else:
6295 
          iprot.skip(ftype)
6296 
      elif fid == 1:
6297 
        if ftype == TType.STRUCT:
6298 
          self.ex = TransactionServiceException()
6299 
          self.ex.read(iprot)
6300 
        else:
6301 
          iprot.skip(ftype)
6302 
      else:
6303 
        iprot.skip(ftype)
6304 
      iprot.readFieldEnd()
6305 
    iprot.readStructEnd()
6306 
 
6307 
  def write(self, oprot):
6308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6310 
      return
6311 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6312 
    if self.success is not None:
94 ashish 6313 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6314 
      oprot.writeBool(self.success)
6315 
      oprot.writeFieldEnd()
3431 rajveer 6316 
    if self.ex is not None:
94 ashish 6317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6318 
      self.ex.write(oprot)
6319 
      oprot.writeFieldEnd()
6320 
    oprot.writeFieldStop()
6321 
    oprot.writeStructEnd()
6322 
 
3431 rajveer 6323 
  def validate(self):
6324 
    return
6325 
 
6326 
 
94 ashish 6327 
  def __repr__(self):
6328 
    L = ['%s=%r' % (key, value)
6329 
      for key, value in self.__dict__.iteritems()]
6330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6331 
 
6332 
  def __eq__(self, other):
6333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6334 
 
6335 
  def __ne__(self, other):
6336 
    return not (self == other)
6337 
 
1398 varun.gupt 6338 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6339 
  """
6340 
  Attributes:
6341 
   - transactionId
6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    None, # 0
6346 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6347 
  )
6348 
 
6349 
  def __init__(self, transactionId=None,):
6350 
    self.transactionId = transactionId
6351 
 
6352 
  def read(self, iprot):
6353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6355 
      return
6356 
    iprot.readStructBegin()
6357 
    while True:
6358 
      (fname, ftype, fid) = iprot.readFieldBegin()
6359 
      if ftype == TType.STOP:
6360 
        break
6361 
      if fid == 1:
6362 
        if ftype == TType.I64:
6363 
          self.transactionId = iprot.readI64();
6364 
        else:
6365 
          iprot.skip(ftype)
6366 
      else:
6367 
        iprot.skip(ftype)
6368 
      iprot.readFieldEnd()
6369 
    iprot.readStructEnd()
6370 
 
6371 
  def write(self, oprot):
6372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6374 
      return
1398 varun.gupt 6375 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6376 
    if self.transactionId is not None:
1382 varun.gupt 6377 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6378 
      oprot.writeI64(self.transactionId)
6379 
      oprot.writeFieldEnd()
6380 
    oprot.writeFieldStop()
6381 
    oprot.writeStructEnd()
6382 
 
3431 rajveer 6383 
  def validate(self):
6384 
    return
6385 
 
6386 
 
1382 varun.gupt 6387 
  def __repr__(self):
6388 
    L = ['%s=%r' % (key, value)
6389 
      for key, value in self.__dict__.iteritems()]
6390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6391 
 
6392 
  def __eq__(self, other):
6393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6394 
 
6395 
  def __ne__(self, other):
6396 
    return not (self == other)
6397 
 
1398 varun.gupt 6398 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6399 
  """
6400 
  Attributes:
6401 
   - success
6402 
   - ex
6403 
  """
6404 
 
6405 
  thrift_spec = (
6406 
    (0, TType.BOOL, 'success', None, None, ), # 0
6407 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6408 
  )
6409 
 
6410 
  def __init__(self, success=None, ex=None,):
6411 
    self.success = success
6412 
    self.ex = ex
6413 
 
6414 
  def read(self, iprot):
6415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6417 
      return
6418 
    iprot.readStructBegin()
6419 
    while True:
6420 
      (fname, ftype, fid) = iprot.readFieldBegin()
6421 
      if ftype == TType.STOP:
6422 
        break
6423 
      if fid == 0:
6424 
        if ftype == TType.BOOL:
6425 
          self.success = iprot.readBool();
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      elif fid == 1:
6429 
        if ftype == TType.STRUCT:
6430 
          self.ex = TransactionServiceException()
6431 
          self.ex.read(iprot)
6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      else:
6435 
        iprot.skip(ftype)
6436 
      iprot.readFieldEnd()
6437 
    iprot.readStructEnd()
6438 
 
6439 
  def write(self, oprot):
6440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6442 
      return
1398 varun.gupt 6443 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6444 
    if self.success is not None:
1382 varun.gupt 6445 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6446 
      oprot.writeBool(self.success)
6447 
      oprot.writeFieldEnd()
3431 rajveer 6448 
    if self.ex is not None:
1382 varun.gupt 6449 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6450 
      self.ex.write(oprot)
6451 
      oprot.writeFieldEnd()
6452 
    oprot.writeFieldStop()
6453 
    oprot.writeStructEnd()
6454 
 
3431 rajveer 6455 
  def validate(self):
6456 
    return
6457 
 
6458 
 
1382 varun.gupt 6459 
  def __repr__(self):
6460 
    L = ['%s=%r' % (key, value)
6461 
      for key, value in self.__dict__.iteritems()]
6462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6463 
 
6464 
  def __eq__(self, other):
6465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6466 
 
6467 
  def __ne__(self, other):
6468 
    return not (self == other)
6469 
 
483 rajveer 6470 
class getAllOrders_args:
94 ashish 6471 
  """
6472 
  Attributes:
483 rajveer 6473 
   - status
6474 
   - from_date
6475 
   - to_date
6476 
   - warehouse_id
94 ashish 6477 
  """
6478 
 
6479 
  thrift_spec = (
6480 
    None, # 0
483 rajveer 6481 
    (1, TType.I32, 'status', None, None, ), # 1
6482 
    (2, TType.I64, 'from_date', None, None, ), # 2
6483 
    (3, TType.I64, 'to_date', None, None, ), # 3
6484 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6485 
  )
6486 
 
483 rajveer 6487 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6488 
    self.status = status
6489 
    self.from_date = from_date
6490 
    self.to_date = to_date
6491 
    self.warehouse_id = warehouse_id
94 ashish 6492 
 
6493 
  def read(self, iprot):
6494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6496 
      return
6497 
    iprot.readStructBegin()
6498 
    while True:
6499 
      (fname, ftype, fid) = iprot.readFieldBegin()
6500 
      if ftype == TType.STOP:
6501 
        break
6502 
      if fid == 1:
483 rajveer 6503 
        if ftype == TType.I32:
6504 
          self.status = iprot.readI32();
94 ashish 6505 
        else:
6506 
          iprot.skip(ftype)
483 rajveer 6507 
      elif fid == 2:
6508 
        if ftype == TType.I64:
6509 
          self.from_date = iprot.readI64();
94 ashish 6510 
        else:
6511 
          iprot.skip(ftype)
483 rajveer 6512 
      elif fid == 3:
6513 
        if ftype == TType.I64:
6514 
          self.to_date = iprot.readI64();
94 ashish 6515 
        else:
6516 
          iprot.skip(ftype)
483 rajveer 6517 
      elif fid == 4:
94 ashish 6518 
        if ftype == TType.I64:
483 rajveer 6519 
          self.warehouse_id = iprot.readI64();
94 ashish 6520 
        else:
6521 
          iprot.skip(ftype)
6522 
      else:
6523 
        iprot.skip(ftype)
6524 
      iprot.readFieldEnd()
6525 
    iprot.readStructEnd()
6526 
 
6527 
  def write(self, oprot):
6528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6530 
      return
483 rajveer 6531 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6532 
    if self.status is not None:
483 rajveer 6533 
      oprot.writeFieldBegin('status', TType.I32, 1)
6534 
      oprot.writeI32(self.status)
94 ashish 6535 
      oprot.writeFieldEnd()
3431 rajveer 6536 
    if self.from_date is not None:
483 rajveer 6537 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6538 
      oprot.writeI64(self.from_date)
94 ashish 6539 
      oprot.writeFieldEnd()
3431 rajveer 6540 
    if self.to_date is not None:
483 rajveer 6541 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6542 
      oprot.writeI64(self.to_date)
94 ashish 6543 
      oprot.writeFieldEnd()
3431 rajveer 6544 
    if self.warehouse_id is not None:
483 rajveer 6545 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6546 
      oprot.writeI64(self.warehouse_id)
94 ashish 6547 
      oprot.writeFieldEnd()
6548 
    oprot.writeFieldStop()
6549 
    oprot.writeStructEnd()
6550 
 
3431 rajveer 6551 
  def validate(self):
6552 
    return
6553 
 
6554 
 
94 ashish 6555 
  def __repr__(self):
6556 
    L = ['%s=%r' % (key, value)
6557 
      for key, value in self.__dict__.iteritems()]
6558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6559 
 
6560 
  def __eq__(self, other):
6561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6562 
 
6563 
  def __ne__(self, other):
6564 
    return not (self == other)
6565 
 
483 rajveer 6566 
class getAllOrders_result:
94 ashish 6567 
  """
6568 
  Attributes:
6569 
   - success
6570 
   - ex
6571 
  """
6572 
 
6573 
  thrift_spec = (
483 rajveer 6574 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6575 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6576 
  )
6577 
 
6578 
  def __init__(self, success=None, ex=None,):
6579 
    self.success = success
6580 
    self.ex = ex
6581 
 
6582 
  def read(self, iprot):
6583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6585 
      return
6586 
    iprot.readStructBegin()
6587 
    while True:
6588 
      (fname, ftype, fid) = iprot.readFieldBegin()
6589 
      if ftype == TType.STOP:
6590 
        break
6591 
      if fid == 0:
483 rajveer 6592 
        if ftype == TType.LIST:
6593 
          self.success = []
685 chandransh 6594 
          (_etype31, _size28) = iprot.readListBegin()
6595 
          for _i32 in xrange(_size28):
6596 
            _elem33 = Order()
6597 
            _elem33.read(iprot)
6598 
            self.success.append(_elem33)
483 rajveer 6599 
          iprot.readListEnd()
94 ashish 6600 
        else:
6601 
          iprot.skip(ftype)
6602 
      elif fid == 1:
6603 
        if ftype == TType.STRUCT:
6604 
          self.ex = TransactionServiceException()
6605 
          self.ex.read(iprot)
6606 
        else:
6607 
          iprot.skip(ftype)
6608 
      else:
6609 
        iprot.skip(ftype)
6610 
      iprot.readFieldEnd()
6611 
    iprot.readStructEnd()
6612 
 
6613 
  def write(self, oprot):
6614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6616 
      return
483 rajveer 6617 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6618 
    if self.success is not None:
483 rajveer 6619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6621 
      for iter34 in self.success:
6622 
        iter34.write(oprot)
483 rajveer 6623 
      oprot.writeListEnd()
94 ashish 6624 
      oprot.writeFieldEnd()
3431 rajveer 6625 
    if self.ex is not None:
94 ashish 6626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6627 
      self.ex.write(oprot)
6628 
      oprot.writeFieldEnd()
6629 
    oprot.writeFieldStop()
6630 
    oprot.writeStructEnd()
6631 
 
3431 rajveer 6632 
  def validate(self):
6633 
    return
6634 
 
6635 
 
94 ashish 6636 
  def __repr__(self):
6637 
    L = ['%s=%r' % (key, value)
6638 
      for key, value in self.__dict__.iteritems()]
6639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6640 
 
6641 
  def __eq__(self, other):
6642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6643 
 
6644 
  def __ne__(self, other):
6645 
    return not (self == other)
6646 
 
4133 chandransh 6647 
class getOrdersInBatch_args:
6648 
  """
6649 
  Attributes:
6650 
   - statuses
6651 
   - offset
6652 
   - limit
6653 
   - warehouse_id
6654 
  """
6655 
 
6656 
  thrift_spec = (
6657 
    None, # 0
6658 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6659 
    (2, TType.I64, 'offset', None, None, ), # 2
6660 
    (3, TType.I64, 'limit', None, None, ), # 3
6661 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6662 
  )
6663 
 
6664 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6665 
    self.statuses = statuses
6666 
    self.offset = offset
6667 
    self.limit = limit
6668 
    self.warehouse_id = warehouse_id
6669 
 
6670 
  def read(self, iprot):
6671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6673 
      return
6674 
    iprot.readStructBegin()
6675 
    while True:
6676 
      (fname, ftype, fid) = iprot.readFieldBegin()
6677 
      if ftype == TType.STOP:
6678 
        break
6679 
      if fid == 1:
6680 
        if ftype == TType.LIST:
6681 
          self.statuses = []
6682 
          (_etype38, _size35) = iprot.readListBegin()
6683 
          for _i39 in xrange(_size35):
6684 
            _elem40 = iprot.readI32();
6685 
            self.statuses.append(_elem40)
6686 
          iprot.readListEnd()
6687 
        else:
6688 
          iprot.skip(ftype)
6689 
      elif fid == 2:
6690 
        if ftype == TType.I64:
6691 
          self.offset = iprot.readI64();
6692 
        else:
6693 
          iprot.skip(ftype)
6694 
      elif fid == 3:
6695 
        if ftype == TType.I64:
6696 
          self.limit = iprot.readI64();
6697 
        else:
6698 
          iprot.skip(ftype)
6699 
      elif fid == 4:
6700 
        if ftype == TType.I64:
6701 
          self.warehouse_id = iprot.readI64();
6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      else:
6705 
        iprot.skip(ftype)
6706 
      iprot.readFieldEnd()
6707 
    iprot.readStructEnd()
6708 
 
6709 
  def write(self, oprot):
6710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6712 
      return
6713 
    oprot.writeStructBegin('getOrdersInBatch_args')
6714 
    if self.statuses is not None:
6715 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6716 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6717 
      for iter41 in self.statuses:
6718 
        oprot.writeI32(iter41)
6719 
      oprot.writeListEnd()
6720 
      oprot.writeFieldEnd()
6721 
    if self.offset is not None:
6722 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6723 
      oprot.writeI64(self.offset)
6724 
      oprot.writeFieldEnd()
6725 
    if self.limit is not None:
6726 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6727 
      oprot.writeI64(self.limit)
6728 
      oprot.writeFieldEnd()
6729 
    if self.warehouse_id is not None:
6730 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6731 
      oprot.writeI64(self.warehouse_id)
6732 
      oprot.writeFieldEnd()
6733 
    oprot.writeFieldStop()
6734 
    oprot.writeStructEnd()
6735 
 
6736 
  def validate(self):
6737 
    return
6738 
 
6739 
 
6740 
  def __repr__(self):
6741 
    L = ['%s=%r' % (key, value)
6742 
      for key, value in self.__dict__.iteritems()]
6743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6744 
 
6745 
  def __eq__(self, other):
6746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6747 
 
6748 
  def __ne__(self, other):
6749 
    return not (self == other)
6750 
 
6751 
class getOrdersInBatch_result:
6752 
  """
6753 
  Attributes:
6754 
   - success
6755 
   - ex
6756 
  """
6757 
 
6758 
  thrift_spec = (
6759 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6761 
  )
6762 
 
6763 
  def __init__(self, success=None, ex=None,):
6764 
    self.success = success
6765 
    self.ex = ex
6766 
 
6767 
  def read(self, iprot):
6768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6770 
      return
6771 
    iprot.readStructBegin()
6772 
    while True:
6773 
      (fname, ftype, fid) = iprot.readFieldBegin()
6774 
      if ftype == TType.STOP:
6775 
        break
6776 
      if fid == 0:
6777 
        if ftype == TType.LIST:
6778 
          self.success = []
6779 
          (_etype45, _size42) = iprot.readListBegin()
6780 
          for _i46 in xrange(_size42):
6781 
            _elem47 = Order()
6782 
            _elem47.read(iprot)
6783 
            self.success.append(_elem47)
6784 
          iprot.readListEnd()
6785 
        else:
6786 
          iprot.skip(ftype)
6787 
      elif fid == 1:
6788 
        if ftype == TType.STRUCT:
6789 
          self.ex = TransactionServiceException()
6790 
          self.ex.read(iprot)
6791 
        else:
6792 
          iprot.skip(ftype)
6793 
      else:
6794 
        iprot.skip(ftype)
6795 
      iprot.readFieldEnd()
6796 
    iprot.readStructEnd()
6797 
 
6798 
  def write(self, oprot):
6799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6801 
      return
6802 
    oprot.writeStructBegin('getOrdersInBatch_result')
6803 
    if self.success is not None:
6804 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6805 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6806 
      for iter48 in self.success:
6807 
        iter48.write(oprot)
6808 
      oprot.writeListEnd()
6809 
      oprot.writeFieldEnd()
6810 
    if self.ex is not None:
6811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6812 
      self.ex.write(oprot)
6813 
      oprot.writeFieldEnd()
6814 
    oprot.writeFieldStop()
6815 
    oprot.writeStructEnd()
6816 
 
6817 
  def validate(self):
6818 
    return
6819 
 
6820 
 
6821 
  def __repr__(self):
6822 
    L = ['%s=%r' % (key, value)
6823 
      for key, value in self.__dict__.iteritems()]
6824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6825 
 
6826 
  def __eq__(self, other):
6827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6828 
 
6829 
  def __ne__(self, other):
6830 
    return not (self == other)
6831 
 
6832 
class getOrderCount_args:
6833 
  """
6834 
  Attributes:
6835 
   - statuses
6836 
   - warehouseId
6837 
  """
6838 
 
6839 
  thrift_spec = (
6840 
    None, # 0
6841 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6842 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6843 
  )
6844 
 
6845 
  def __init__(self, statuses=None, warehouseId=None,):
6846 
    self.statuses = statuses
6847 
    self.warehouseId = warehouseId
6848 
 
6849 
  def read(self, iprot):
6850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6852 
      return
6853 
    iprot.readStructBegin()
6854 
    while True:
6855 
      (fname, ftype, fid) = iprot.readFieldBegin()
6856 
      if ftype == TType.STOP:
6857 
        break
6858 
      if fid == 1:
6859 
        if ftype == TType.LIST:
6860 
          self.statuses = []
6861 
          (_etype52, _size49) = iprot.readListBegin()
6862 
          for _i53 in xrange(_size49):
6863 
            _elem54 = iprot.readI32();
6864 
            self.statuses.append(_elem54)
6865 
          iprot.readListEnd()
6866 
        else:
6867 
          iprot.skip(ftype)
6868 
      elif fid == 2:
6869 
        if ftype == TType.I64:
6870 
          self.warehouseId = iprot.readI64();
6871 
        else:
6872 
          iprot.skip(ftype)
6873 
      else:
6874 
        iprot.skip(ftype)
6875 
      iprot.readFieldEnd()
6876 
    iprot.readStructEnd()
6877 
 
6878 
  def write(self, oprot):
6879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6881 
      return
6882 
    oprot.writeStructBegin('getOrderCount_args')
6883 
    if self.statuses is not None:
6884 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6885 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6886 
      for iter55 in self.statuses:
6887 
        oprot.writeI32(iter55)
6888 
      oprot.writeListEnd()
6889 
      oprot.writeFieldEnd()
6890 
    if self.warehouseId is not None:
6891 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6892 
      oprot.writeI64(self.warehouseId)
6893 
      oprot.writeFieldEnd()
6894 
    oprot.writeFieldStop()
6895 
    oprot.writeStructEnd()
6896 
 
6897 
  def validate(self):
6898 
    return
6899 
 
6900 
 
6901 
  def __repr__(self):
6902 
    L = ['%s=%r' % (key, value)
6903 
      for key, value in self.__dict__.iteritems()]
6904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6905 
 
6906 
  def __eq__(self, other):
6907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6908 
 
6909 
  def __ne__(self, other):
6910 
    return not (self == other)
6911 
 
6912 
class getOrderCount_result:
6913 
  """
6914 
  Attributes:
6915 
   - success
6916 
   - ex
6917 
  """
6918 
 
6919 
  thrift_spec = (
6920 
    (0, TType.I32, 'success', None, None, ), # 0
6921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6922 
  )
6923 
 
6924 
  def __init__(self, success=None, ex=None,):
6925 
    self.success = success
6926 
    self.ex = ex
6927 
 
6928 
  def read(self, iprot):
6929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6931 
      return
6932 
    iprot.readStructBegin()
6933 
    while True:
6934 
      (fname, ftype, fid) = iprot.readFieldBegin()
6935 
      if ftype == TType.STOP:
6936 
        break
6937 
      if fid == 0:
6938 
        if ftype == TType.I32:
6939 
          self.success = iprot.readI32();
6940 
        else:
6941 
          iprot.skip(ftype)
6942 
      elif fid == 1:
6943 
        if ftype == TType.STRUCT:
6944 
          self.ex = TransactionServiceException()
6945 
          self.ex.read(iprot)
6946 
        else:
6947 
          iprot.skip(ftype)
6948 
      else:
6949 
        iprot.skip(ftype)
6950 
      iprot.readFieldEnd()
6951 
    iprot.readStructEnd()
6952 
 
6953 
  def write(self, oprot):
6954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6956 
      return
6957 
    oprot.writeStructBegin('getOrderCount_result')
6958 
    if self.success is not None:
6959 
      oprot.writeFieldBegin('success', TType.I32, 0)
6960 
      oprot.writeI32(self.success)
6961 
      oprot.writeFieldEnd()
6962 
    if self.ex is not None:
6963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6964 
      self.ex.write(oprot)
6965 
      oprot.writeFieldEnd()
6966 
    oprot.writeFieldStop()
6967 
    oprot.writeStructEnd()
6968 
 
6969 
  def validate(self):
6970 
    return
6971 
 
6972 
 
6973 
  def __repr__(self):
6974 
    L = ['%s=%r' % (key, value)
6975 
      for key, value in self.__dict__.iteritems()]
6976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6977 
 
6978 
  def __eq__(self, other):
6979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6980 
 
6981 
  def __ne__(self, other):
6982 
    return not (self == other)
6983 
 
999 varun.gupt 6984 
class getOrdersByBillingDate_args:
6985 
  """
6986 
  Attributes:
6987 
   - status
6988 
   - start_billing_date
6989 
   - end_billing_date
6990 
   - warehouse_id
6991 
  """
6992 
 
6993 
  thrift_spec = (
6994 
    None, # 0
6995 
    (1, TType.I32, 'status', None, None, ), # 1
6996 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6997 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6998 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6999 
  )
7000 
 
7001 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7002 
    self.status = status
7003 
    self.start_billing_date = start_billing_date
7004 
    self.end_billing_date = end_billing_date
7005 
    self.warehouse_id = warehouse_id
7006 
 
7007 
  def read(self, iprot):
7008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7010 
      return
7011 
    iprot.readStructBegin()
7012 
    while True:
7013 
      (fname, ftype, fid) = iprot.readFieldBegin()
7014 
      if ftype == TType.STOP:
7015 
        break
7016 
      if fid == 1:
7017 
        if ftype == TType.I32:
7018 
          self.status = iprot.readI32();
7019 
        else:
7020 
          iprot.skip(ftype)
7021 
      elif fid == 2:
7022 
        if ftype == TType.I64:
7023 
          self.start_billing_date = iprot.readI64();
7024 
        else:
7025 
          iprot.skip(ftype)
7026 
      elif fid == 3:
7027 
        if ftype == TType.I64:
7028 
          self.end_billing_date = iprot.readI64();
7029 
        else:
7030 
          iprot.skip(ftype)
7031 
      elif fid == 4:
7032 
        if ftype == TType.I64:
7033 
          self.warehouse_id = iprot.readI64();
7034 
        else:
7035 
          iprot.skip(ftype)
7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
7045 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7046 
    if self.status is not None:
999 varun.gupt 7047 
      oprot.writeFieldBegin('status', TType.I32, 1)
7048 
      oprot.writeI32(self.status)
7049 
      oprot.writeFieldEnd()
3431 rajveer 7050 
    if self.start_billing_date is not None:
999 varun.gupt 7051 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7052 
      oprot.writeI64(self.start_billing_date)
7053 
      oprot.writeFieldEnd()
3431 rajveer 7054 
    if self.end_billing_date is not None:
999 varun.gupt 7055 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7056 
      oprot.writeI64(self.end_billing_date)
7057 
      oprot.writeFieldEnd()
3431 rajveer 7058 
    if self.warehouse_id is not None:
999 varun.gupt 7059 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7060 
      oprot.writeI64(self.warehouse_id)
7061 
      oprot.writeFieldEnd()
7062 
    oprot.writeFieldStop()
7063 
    oprot.writeStructEnd()
7064 
 
3431 rajveer 7065 
  def validate(self):
7066 
    return
7067 
 
7068 
 
999 varun.gupt 7069 
  def __repr__(self):
7070 
    L = ['%s=%r' % (key, value)
7071 
      for key, value in self.__dict__.iteritems()]
7072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7073 
 
7074 
  def __eq__(self, other):
7075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7076 
 
7077 
  def __ne__(self, other):
7078 
    return not (self == other)
7079 
 
7080 
class getOrdersByBillingDate_result:
7081 
  """
7082 
  Attributes:
7083 
   - success
7084 
   - ex
7085 
  """
7086 
 
7087 
  thrift_spec = (
7088 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7089 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7090 
  )
7091 
 
7092 
  def __init__(self, success=None, ex=None,):
7093 
    self.success = success
7094 
    self.ex = ex
7095 
 
7096 
  def read(self, iprot):
7097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7099 
      return
7100 
    iprot.readStructBegin()
7101 
    while True:
7102 
      (fname, ftype, fid) = iprot.readFieldBegin()
7103 
      if ftype == TType.STOP:
7104 
        break
7105 
      if fid == 0:
7106 
        if ftype == TType.LIST:
7107 
          self.success = []
4133 chandransh 7108 
          (_etype59, _size56) = iprot.readListBegin()
7109 
          for _i60 in xrange(_size56):
7110 
            _elem61 = Order()
7111 
            _elem61.read(iprot)
7112 
            self.success.append(_elem61)
999 varun.gupt 7113 
          iprot.readListEnd()
7114 
        else:
7115 
          iprot.skip(ftype)
7116 
      elif fid == 1:
7117 
        if ftype == TType.STRUCT:
7118 
          self.ex = TransactionServiceException()
7119 
          self.ex.read(iprot)
7120 
        else:
7121 
          iprot.skip(ftype)
7122 
      else:
7123 
        iprot.skip(ftype)
7124 
      iprot.readFieldEnd()
7125 
    iprot.readStructEnd()
7126 
 
7127 
  def write(self, oprot):
7128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7130 
      return
7131 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7132 
    if self.success is not None:
999 varun.gupt 7133 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7134 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7135 
      for iter62 in self.success:
7136 
        iter62.write(oprot)
999 varun.gupt 7137 
      oprot.writeListEnd()
7138 
      oprot.writeFieldEnd()
3431 rajveer 7139 
    if self.ex is not None:
999 varun.gupt 7140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7141 
      self.ex.write(oprot)
7142 
      oprot.writeFieldEnd()
7143 
    oprot.writeFieldStop()
7144 
    oprot.writeStructEnd()
7145 
 
3431 rajveer 7146 
  def validate(self):
7147 
    return
7148 
 
7149 
 
999 varun.gupt 7150 
  def __repr__(self):
7151 
    L = ['%s=%r' % (key, value)
7152 
      for key, value in self.__dict__.iteritems()]
7153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7154 
 
7155 
  def __eq__(self, other):
7156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7157 
 
7158 
  def __ne__(self, other):
7159 
    return not (self == other)
7160 
 
3427 chandransh 7161 
class getOrdersByShippingDate_args:
7162 
  """
7163 
  Attributes:
7164 
   - fromShippingDate
7165 
   - toShippingDate
7166 
   - providerId
7167 
   - warehouseId
3451 chandransh 7168 
   - cod
3427 chandransh 7169 
  """
7170 
 
7171 
  thrift_spec = (
7172 
    None, # 0
7173 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7174 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7175 
    (3, TType.I64, 'providerId', None, None, ), # 3
7176 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7177 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7178 
  )
7179 
 
3451 chandransh 7180 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7181 
    self.fromShippingDate = fromShippingDate
7182 
    self.toShippingDate = toShippingDate
7183 
    self.providerId = providerId
7184 
    self.warehouseId = warehouseId
3451 chandransh 7185 
    self.cod = cod
3427 chandransh 7186 
 
7187 
  def read(self, iprot):
7188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7190 
      return
7191 
    iprot.readStructBegin()
7192 
    while True:
7193 
      (fname, ftype, fid) = iprot.readFieldBegin()
7194 
      if ftype == TType.STOP:
7195 
        break
7196 
      if fid == 1:
7197 
        if ftype == TType.I64:
7198 
          self.fromShippingDate = iprot.readI64();
7199 
        else:
7200 
          iprot.skip(ftype)
7201 
      elif fid == 2:
7202 
        if ftype == TType.I64:
7203 
          self.toShippingDate = iprot.readI64();
7204 
        else:
7205 
          iprot.skip(ftype)
7206 
      elif fid == 3:
7207 
        if ftype == TType.I64:
7208 
          self.providerId = iprot.readI64();
7209 
        else:
7210 
          iprot.skip(ftype)
7211 
      elif fid == 4:
7212 
        if ftype == TType.I64:
7213 
          self.warehouseId = iprot.readI64();
7214 
        else:
7215 
          iprot.skip(ftype)
3451 chandransh 7216 
      elif fid == 5:
7217 
        if ftype == TType.BOOL:
7218 
          self.cod = iprot.readBool();
7219 
        else:
7220 
          iprot.skip(ftype)
3427 chandransh 7221 
      else:
7222 
        iprot.skip(ftype)
7223 
      iprot.readFieldEnd()
7224 
    iprot.readStructEnd()
7225 
 
7226 
  def write(self, oprot):
7227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7229 
      return
7230 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7231 
    if self.fromShippingDate is not None:
3427 chandransh 7232 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7233 
      oprot.writeI64(self.fromShippingDate)
7234 
      oprot.writeFieldEnd()
3431 rajveer 7235 
    if self.toShippingDate is not None:
3427 chandransh 7236 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7237 
      oprot.writeI64(self.toShippingDate)
7238 
      oprot.writeFieldEnd()
3431 rajveer 7239 
    if self.providerId is not None:
3427 chandransh 7240 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7241 
      oprot.writeI64(self.providerId)
7242 
      oprot.writeFieldEnd()
3431 rajveer 7243 
    if self.warehouseId is not None:
3427 chandransh 7244 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7245 
      oprot.writeI64(self.warehouseId)
7246 
      oprot.writeFieldEnd()
3451 chandransh 7247 
    if self.cod is not None:
7248 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7249 
      oprot.writeBool(self.cod)
7250 
      oprot.writeFieldEnd()
3427 chandransh 7251 
    oprot.writeFieldStop()
7252 
    oprot.writeStructEnd()
7253 
 
3431 rajveer 7254 
  def validate(self):
7255 
    return
7256 
 
7257 
 
3427 chandransh 7258 
  def __repr__(self):
7259 
    L = ['%s=%r' % (key, value)
7260 
      for key, value in self.__dict__.iteritems()]
7261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7262 
 
7263 
  def __eq__(self, other):
7264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7265 
 
7266 
  def __ne__(self, other):
7267 
    return not (self == other)
7268 
 
7269 
class getOrdersByShippingDate_result:
7270 
  """
7271 
  Attributes:
7272 
   - success
7273 
   - ex
7274 
  """
7275 
 
7276 
  thrift_spec = (
7277 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7279 
  )
7280 
 
7281 
  def __init__(self, success=None, ex=None,):
7282 
    self.success = success
7283 
    self.ex = ex
7284 
 
7285 
  def read(self, iprot):
7286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7288 
      return
7289 
    iprot.readStructBegin()
7290 
    while True:
7291 
      (fname, ftype, fid) = iprot.readFieldBegin()
7292 
      if ftype == TType.STOP:
7293 
        break
7294 
      if fid == 0:
7295 
        if ftype == TType.LIST:
7296 
          self.success = []
4133 chandransh 7297 
          (_etype66, _size63) = iprot.readListBegin()
7298 
          for _i67 in xrange(_size63):
7299 
            _elem68 = Order()
7300 
            _elem68.read(iprot)
7301 
            self.success.append(_elem68)
3427 chandransh 7302 
          iprot.readListEnd()
7303 
        else:
7304 
          iprot.skip(ftype)
7305 
      elif fid == 1:
7306 
        if ftype == TType.STRUCT:
7307 
          self.ex = TransactionServiceException()
7308 
          self.ex.read(iprot)
7309 
        else:
7310 
          iprot.skip(ftype)
7311 
      else:
7312 
        iprot.skip(ftype)
7313 
      iprot.readFieldEnd()
7314 
    iprot.readStructEnd()
7315 
 
7316 
  def write(self, oprot):
7317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7319 
      return
7320 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7321 
    if self.success is not None:
3427 chandransh 7322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7324 
      for iter69 in self.success:
7325 
        iter69.write(oprot)
3427 chandransh 7326 
      oprot.writeListEnd()
7327 
      oprot.writeFieldEnd()
3431 rajveer 7328 
    if self.ex is not None:
3427 chandransh 7329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7330 
      self.ex.write(oprot)
7331 
      oprot.writeFieldEnd()
7332 
    oprot.writeFieldStop()
7333 
    oprot.writeStructEnd()
7334 
 
3431 rajveer 7335 
  def validate(self):
7336 
    return
7337 
 
7338 
 
3427 chandransh 7339 
  def __repr__(self):
7340 
    L = ['%s=%r' % (key, value)
7341 
      for key, value in self.__dict__.iteritems()]
7342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7343 
 
7344 
  def __eq__(self, other):
7345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7346 
 
7347 
  def __ne__(self, other):
7348 
    return not (self == other)
7349 
 
1382 varun.gupt 7350 
class getReturnableOrdersForCustomer_args:
7351 
  """
7352 
  Attributes:
7353 
   - customer_id
7354 
   - limit
7355 
  """
7356 
 
7357 
  thrift_spec = (
7358 
    None, # 0
7359 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7360 
    (2, TType.I64, 'limit', None, None, ), # 2
7361 
  )
7362 
 
7363 
  def __init__(self, customer_id=None, limit=None,):
7364 
    self.customer_id = customer_id
7365 
    self.limit = limit
7366 
 
7367 
  def read(self, iprot):
7368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7370 
      return
7371 
    iprot.readStructBegin()
7372 
    while True:
7373 
      (fname, ftype, fid) = iprot.readFieldBegin()
7374 
      if ftype == TType.STOP:
7375 
        break
7376 
      if fid == 1:
7377 
        if ftype == TType.I64:
7378 
          self.customer_id = iprot.readI64();
7379 
        else:
7380 
          iprot.skip(ftype)
7381 
      elif fid == 2:
7382 
        if ftype == TType.I64:
7383 
          self.limit = iprot.readI64();
7384 
        else:
7385 
          iprot.skip(ftype)
7386 
      else:
7387 
        iprot.skip(ftype)
7388 
      iprot.readFieldEnd()
7389 
    iprot.readStructEnd()
7390 
 
7391 
  def write(self, oprot):
7392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7394 
      return
7395 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7396 
    if self.customer_id is not None:
1382 varun.gupt 7397 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7398 
      oprot.writeI64(self.customer_id)
7399 
      oprot.writeFieldEnd()
3431 rajveer 7400 
    if self.limit is not None:
1382 varun.gupt 7401 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7402 
      oprot.writeI64(self.limit)
7403 
      oprot.writeFieldEnd()
7404 
    oprot.writeFieldStop()
7405 
    oprot.writeStructEnd()
7406 
 
3431 rajveer 7407 
  def validate(self):
7408 
    return
7409 
 
7410 
 
1382 varun.gupt 7411 
  def __repr__(self):
7412 
    L = ['%s=%r' % (key, value)
7413 
      for key, value in self.__dict__.iteritems()]
7414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7415 
 
7416 
  def __eq__(self, other):
7417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7418 
 
7419 
  def __ne__(self, other):
7420 
    return not (self == other)
7421 
 
7422 
class getReturnableOrdersForCustomer_result:
7423 
  """
7424 
  Attributes:
7425 
   - success
7426 
   - ex
7427 
  """
7428 
 
7429 
  thrift_spec = (
7430 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7432 
  )
7433 
 
7434 
  def __init__(self, success=None, ex=None,):
7435 
    self.success = success
7436 
    self.ex = ex
7437 
 
7438 
  def read(self, iprot):
7439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7441 
      return
7442 
    iprot.readStructBegin()
7443 
    while True:
7444 
      (fname, ftype, fid) = iprot.readFieldBegin()
7445 
      if ftype == TType.STOP:
7446 
        break
7447 
      if fid == 0:
7448 
        if ftype == TType.LIST:
7449 
          self.success = []
4133 chandransh 7450 
          (_etype73, _size70) = iprot.readListBegin()
7451 
          for _i74 in xrange(_size70):
7452 
            _elem75 = iprot.readI64();
7453 
            self.success.append(_elem75)
1382 varun.gupt 7454 
          iprot.readListEnd()
7455 
        else:
7456 
          iprot.skip(ftype)
7457 
      elif fid == 1:
7458 
        if ftype == TType.STRUCT:
7459 
          self.ex = TransactionServiceException()
7460 
          self.ex.read(iprot)
7461 
        else:
7462 
          iprot.skip(ftype)
7463 
      else:
7464 
        iprot.skip(ftype)
7465 
      iprot.readFieldEnd()
7466 
    iprot.readStructEnd()
7467 
 
7468 
  def write(self, oprot):
7469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7471 
      return
7472 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7473 
    if self.success is not None:
1382 varun.gupt 7474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7475 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7476 
      for iter76 in self.success:
7477 
        oprot.writeI64(iter76)
1382 varun.gupt 7478 
      oprot.writeListEnd()
7479 
      oprot.writeFieldEnd()
3431 rajveer 7480 
    if self.ex is not None:
1382 varun.gupt 7481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7482 
      self.ex.write(oprot)
7483 
      oprot.writeFieldEnd()
7484 
    oprot.writeFieldStop()
7485 
    oprot.writeStructEnd()
7486 
 
3431 rajveer 7487 
  def validate(self):
7488 
    return
7489 
 
7490 
 
1382 varun.gupt 7491 
  def __repr__(self):
7492 
    L = ['%s=%r' % (key, value)
7493 
      for key, value in self.__dict__.iteritems()]
7494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7495 
 
7496 
  def __eq__(self, other):
7497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7498 
 
7499 
  def __ne__(self, other):
7500 
    return not (self == other)
7501 
 
7502 
class getCancellableOrdersForCustomer_args:
7503 
  """
7504 
  Attributes:
7505 
   - customer_id
7506 
   - limit
7507 
  """
7508 
 
7509 
  thrift_spec = (
7510 
    None, # 0
7511 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7512 
    (2, TType.I64, 'limit', None, None, ), # 2
7513 
  )
7514 
 
7515 
  def __init__(self, customer_id=None, limit=None,):
7516 
    self.customer_id = customer_id
7517 
    self.limit = limit
7518 
 
7519 
  def read(self, iprot):
7520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7522 
      return
7523 
    iprot.readStructBegin()
7524 
    while True:
7525 
      (fname, ftype, fid) = iprot.readFieldBegin()
7526 
      if ftype == TType.STOP:
7527 
        break
7528 
      if fid == 1:
7529 
        if ftype == TType.I64:
7530 
          self.customer_id = iprot.readI64();
7531 
        else:
7532 
          iprot.skip(ftype)
7533 
      elif fid == 2:
7534 
        if ftype == TType.I64:
7535 
          self.limit = iprot.readI64();
7536 
        else:
7537 
          iprot.skip(ftype)
7538 
      else:
7539 
        iprot.skip(ftype)
7540 
      iprot.readFieldEnd()
7541 
    iprot.readStructEnd()
7542 
 
7543 
  def write(self, oprot):
7544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7546 
      return
7547 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7548 
    if self.customer_id is not None:
1382 varun.gupt 7549 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7550 
      oprot.writeI64(self.customer_id)
7551 
      oprot.writeFieldEnd()
3431 rajveer 7552 
    if self.limit is not None:
1382 varun.gupt 7553 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7554 
      oprot.writeI64(self.limit)
7555 
      oprot.writeFieldEnd()
7556 
    oprot.writeFieldStop()
7557 
    oprot.writeStructEnd()
7558 
 
3431 rajveer 7559 
  def validate(self):
7560 
    return
7561 
 
7562 
 
1382 varun.gupt 7563 
  def __repr__(self):
7564 
    L = ['%s=%r' % (key, value)
7565 
      for key, value in self.__dict__.iteritems()]
7566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7567 
 
7568 
  def __eq__(self, other):
7569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7570 
 
7571 
  def __ne__(self, other):
7572 
    return not (self == other)
7573 
 
7574 
class getCancellableOrdersForCustomer_result:
7575 
  """
7576 
  Attributes:
7577 
   - success
7578 
   - ex
7579 
  """
7580 
 
7581 
  thrift_spec = (
7582 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7584 
  )
7585 
 
7586 
  def __init__(self, success=None, ex=None,):
7587 
    self.success = success
7588 
    self.ex = ex
7589 
 
7590 
  def read(self, iprot):
7591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7593 
      return
7594 
    iprot.readStructBegin()
7595 
    while True:
7596 
      (fname, ftype, fid) = iprot.readFieldBegin()
7597 
      if ftype == TType.STOP:
7598 
        break
7599 
      if fid == 0:
7600 
        if ftype == TType.LIST:
7601 
          self.success = []
4133 chandransh 7602 
          (_etype80, _size77) = iprot.readListBegin()
7603 
          for _i81 in xrange(_size77):
7604 
            _elem82 = iprot.readI64();
7605 
            self.success.append(_elem82)
1382 varun.gupt 7606 
          iprot.readListEnd()
7607 
        else:
7608 
          iprot.skip(ftype)
7609 
      elif fid == 1:
7610 
        if ftype == TType.STRUCT:
7611 
          self.ex = TransactionServiceException()
7612 
          self.ex.read(iprot)
7613 
        else:
7614 
          iprot.skip(ftype)
7615 
      else:
7616 
        iprot.skip(ftype)
7617 
      iprot.readFieldEnd()
7618 
    iprot.readStructEnd()
7619 
 
7620 
  def write(self, oprot):
7621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7623 
      return
7624 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7625 
    if self.success is not None:
1382 varun.gupt 7626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7627 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7628 
      for iter83 in self.success:
7629 
        oprot.writeI64(iter83)
1382 varun.gupt 7630 
      oprot.writeListEnd()
7631 
      oprot.writeFieldEnd()
3431 rajveer 7632 
    if self.ex is not None:
1382 varun.gupt 7633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7634 
      self.ex.write(oprot)
7635 
      oprot.writeFieldEnd()
7636 
    oprot.writeFieldStop()
7637 
    oprot.writeStructEnd()
7638 
 
3431 rajveer 7639 
  def validate(self):
7640 
    return
7641 
 
7642 
 
1382 varun.gupt 7643 
  def __repr__(self):
7644 
    L = ['%s=%r' % (key, value)
7645 
      for key, value in self.__dict__.iteritems()]
7646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7647 
 
7648 
  def __eq__(self, other):
7649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7650 
 
7651 
  def __ne__(self, other):
7652 
    return not (self == other)
7653 
 
483 rajveer 7654 
class changeOrderStatus_args:
94 ashish 7655 
  """
7656 
  Attributes:
483 rajveer 7657 
   - orderId
7658 
   - status
7659 
   - description
94 ashish 7660 
  """
7661 
 
7662 
  thrift_spec = (
7663 
    None, # 0
483 rajveer 7664 
    (1, TType.I64, 'orderId', None, None, ), # 1
7665 
    (2, TType.I32, 'status', None, None, ), # 2
7666 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7667 
  )
7668 
 
483 rajveer 7669 
  def __init__(self, orderId=None, status=None, description=None,):
7670 
    self.orderId = orderId
7671 
    self.status = status
7672 
    self.description = description
94 ashish 7673 
 
7674 
  def read(self, iprot):
7675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7677 
      return
7678 
    iprot.readStructBegin()
7679 
    while True:
7680 
      (fname, ftype, fid) = iprot.readFieldBegin()
7681 
      if ftype == TType.STOP:
7682 
        break
7683 
      if fid == 1:
7684 
        if ftype == TType.I64:
483 rajveer 7685 
          self.orderId = iprot.readI64();
94 ashish 7686 
        else:
7687 
          iprot.skip(ftype)
7688 
      elif fid == 2:
483 rajveer 7689 
        if ftype == TType.I32:
7690 
          self.status = iprot.readI32();
94 ashish 7691 
        else:
7692 
          iprot.skip(ftype)
483 rajveer 7693 
      elif fid == 3:
7694 
        if ftype == TType.STRING:
7695 
          self.description = iprot.readString();
7696 
        else:
7697 
          iprot.skip(ftype)
94 ashish 7698 
      else:
7699 
        iprot.skip(ftype)
7700 
      iprot.readFieldEnd()
7701 
    iprot.readStructEnd()
7702 
 
7703 
  def write(self, oprot):
7704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7706 
      return
483 rajveer 7707 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7708 
    if self.orderId is not None:
483 rajveer 7709 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7710 
      oprot.writeI64(self.orderId)
94 ashish 7711 
      oprot.writeFieldEnd()
3431 rajveer 7712 
    if self.status is not None:
483 rajveer 7713 
      oprot.writeFieldBegin('status', TType.I32, 2)
7714 
      oprot.writeI32(self.status)
94 ashish 7715 
      oprot.writeFieldEnd()
3431 rajveer 7716 
    if self.description is not None:
483 rajveer 7717 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7718 
      oprot.writeString(self.description)
7719 
      oprot.writeFieldEnd()
94 ashish 7720 
    oprot.writeFieldStop()
7721 
    oprot.writeStructEnd()
7722 
 
3431 rajveer 7723 
  def validate(self):
7724 
    return
7725 
 
7726 
 
94 ashish 7727 
  def __repr__(self):
7728 
    L = ['%s=%r' % (key, value)
7729 
      for key, value in self.__dict__.iteritems()]
7730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7731 
 
7732 
  def __eq__(self, other):
7733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7734 
 
7735 
  def __ne__(self, other):
7736 
    return not (self == other)
7737 
 
483 rajveer 7738 
class changeOrderStatus_result:
94 ashish 7739 
  """
7740 
  Attributes:
7741 
   - success
7742 
   - ex
7743 
  """
7744 
 
7745 
  thrift_spec = (
7746 
    (0, TType.BOOL, 'success', None, None, ), # 0
7747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7748 
  )
7749 
 
7750 
  def __init__(self, success=None, ex=None,):
7751 
    self.success = success
7752 
    self.ex = ex
7753 
 
7754 
  def read(self, iprot):
7755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7757 
      return
7758 
    iprot.readStructBegin()
7759 
    while True:
7760 
      (fname, ftype, fid) = iprot.readFieldBegin()
7761 
      if ftype == TType.STOP:
7762 
        break
7763 
      if fid == 0:
7764 
        if ftype == TType.BOOL:
7765 
          self.success = iprot.readBool();
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      elif fid == 1:
7769 
        if ftype == TType.STRUCT:
7770 
          self.ex = TransactionServiceException()
7771 
          self.ex.read(iprot)
7772 
        else:
7773 
          iprot.skip(ftype)
7774 
      else:
7775 
        iprot.skip(ftype)
7776 
      iprot.readFieldEnd()
7777 
    iprot.readStructEnd()
7778 
 
7779 
  def write(self, oprot):
7780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7782 
      return
483 rajveer 7783 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7784 
    if self.success is not None:
94 ashish 7785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7786 
      oprot.writeBool(self.success)
7787 
      oprot.writeFieldEnd()
3431 rajveer 7788 
    if self.ex is not None:
94 ashish 7789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7790 
      self.ex.write(oprot)
7791 
      oprot.writeFieldEnd()
7792 
    oprot.writeFieldStop()
7793 
    oprot.writeStructEnd()
7794 
 
3431 rajveer 7795 
  def validate(self):
7796 
    return
7797 
 
7798 
 
94 ashish 7799 
  def __repr__(self):
7800 
    L = ['%s=%r' % (key, value)
7801 
      for key, value in self.__dict__.iteritems()]
7802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7803 
 
7804 
  def __eq__(self, other):
7805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7806 
 
7807 
  def __ne__(self, other):
7808 
    return not (self == other)
7809 
 
3064 chandransh 7810 
class getOrdersForTransaction_args:
494 rajveer 7811 
  """
7812 
  Attributes:
3064 chandransh 7813 
   - transactionId
7814 
   - customerId
494 rajveer 7815 
  """
7816 
 
7817 
  thrift_spec = (
7818 
    None, # 0
3064 chandransh 7819 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7820 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7821 
  )
7822 
 
3064 chandransh 7823 
  def __init__(self, transactionId=None, customerId=None,):
7824 
    self.transactionId = transactionId
7825 
    self.customerId = customerId
494 rajveer 7826 
 
7827 
  def read(self, iprot):
7828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7830 
      return
7831 
    iprot.readStructBegin()
7832 
    while True:
7833 
      (fname, ftype, fid) = iprot.readFieldBegin()
7834 
      if ftype == TType.STOP:
7835 
        break
7836 
      if fid == 1:
7837 
        if ftype == TType.I64:
3064 chandransh 7838 
          self.transactionId = iprot.readI64();
494 rajveer 7839 
        else:
7840 
          iprot.skip(ftype)
7841 
      elif fid == 2:
3064 chandransh 7842 
        if ftype == TType.I64:
7843 
          self.customerId = iprot.readI64();
494 rajveer 7844 
        else:
7845 
          iprot.skip(ftype)
7846 
      else:
7847 
        iprot.skip(ftype)
7848 
      iprot.readFieldEnd()
7849 
    iprot.readStructEnd()
7850 
 
7851 
  def write(self, oprot):
7852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7854 
      return
3064 chandransh 7855 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7856 
    if self.transactionId is not None:
3064 chandransh 7857 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7858 
      oprot.writeI64(self.transactionId)
494 rajveer 7859 
      oprot.writeFieldEnd()
3431 rajveer 7860 
    if self.customerId is not None:
3064 chandransh 7861 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7862 
      oprot.writeI64(self.customerId)
494 rajveer 7863 
      oprot.writeFieldEnd()
7864 
    oprot.writeFieldStop()
7865 
    oprot.writeStructEnd()
7866 
 
3431 rajveer 7867 
  def validate(self):
7868 
    return
7869 
 
7870 
 
494 rajveer 7871 
  def __repr__(self):
7872 
    L = ['%s=%r' % (key, value)
7873 
      for key, value in self.__dict__.iteritems()]
7874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7875 
 
7876 
  def __eq__(self, other):
7877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7878 
 
7879 
  def __ne__(self, other):
7880 
    return not (self == other)
7881 
 
3064 chandransh 7882 
class getOrdersForTransaction_result:
494 rajveer 7883 
  """
7884 
  Attributes:
7885 
   - success
7886 
   - ex
7887 
  """
7888 
 
7889 
  thrift_spec = (
3064 chandransh 7890 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7892 
  )
7893 
 
7894 
  def __init__(self, success=None, ex=None,):
7895 
    self.success = success
7896 
    self.ex = ex
7897 
 
7898 
  def read(self, iprot):
7899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7901 
      return
7902 
    iprot.readStructBegin()
7903 
    while True:
7904 
      (fname, ftype, fid) = iprot.readFieldBegin()
7905 
      if ftype == TType.STOP:
7906 
        break
7907 
      if fid == 0:
3064 chandransh 7908 
        if ftype == TType.LIST:
7909 
          self.success = []
4133 chandransh 7910 
          (_etype87, _size84) = iprot.readListBegin()
7911 
          for _i88 in xrange(_size84):
7912 
            _elem89 = Order()
7913 
            _elem89.read(iprot)
7914 
            self.success.append(_elem89)
3064 chandransh 7915 
          iprot.readListEnd()
494 rajveer 7916 
        else:
7917 
          iprot.skip(ftype)
7918 
      elif fid == 1:
7919 
        if ftype == TType.STRUCT:
7920 
          self.ex = TransactionServiceException()
7921 
          self.ex.read(iprot)
7922 
        else:
7923 
          iprot.skip(ftype)
7924 
      else:
7925 
        iprot.skip(ftype)
7926 
      iprot.readFieldEnd()
7927 
    iprot.readStructEnd()
7928 
 
7929 
  def write(self, oprot):
7930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7932 
      return
3064 chandransh 7933 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7934 
    if self.success is not None:
3064 chandransh 7935 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7936 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7937 
      for iter90 in self.success:
7938 
        iter90.write(oprot)
3064 chandransh 7939 
      oprot.writeListEnd()
494 rajveer 7940 
      oprot.writeFieldEnd()
3431 rajveer 7941 
    if self.ex is not None:
494 rajveer 7942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7943 
      self.ex.write(oprot)
7944 
      oprot.writeFieldEnd()
7945 
    oprot.writeFieldStop()
7946 
    oprot.writeStructEnd()
7947 
 
3431 rajveer 7948 
  def validate(self):
7949 
    return
7950 
 
7951 
 
494 rajveer 7952 
  def __repr__(self):
7953 
    L = ['%s=%r' % (key, value)
7954 
      for key, value in self.__dict__.iteritems()]
7955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7956 
 
7957 
  def __eq__(self, other):
7958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7959 
 
7960 
  def __ne__(self, other):
7961 
    return not (self == other)
7962 
 
3064 chandransh 7963 
class getOrdersForCustomer_args:
1149 chandransh 7964 
  """
7965 
  Attributes:
3064 chandransh 7966 
   - customerId
7967 
   - from_date
7968 
   - to_date
7969 
   - statuses
1149 chandransh 7970 
  """
7971 
 
7972 
  thrift_spec = (
7973 
    None, # 0
3064 chandransh 7974 
    (1, TType.I64, 'customerId', None, None, ), # 1
7975 
    (2, TType.I64, 'from_date', None, None, ), # 2
7976 
    (3, TType.I64, 'to_date', None, None, ), # 3
7977 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7978 
  )
7979 
 
3064 chandransh 7980 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7981 
    self.customerId = customerId
7982 
    self.from_date = from_date
7983 
    self.to_date = to_date
7984 
    self.statuses = statuses
1149 chandransh 7985 
 
7986 
  def read(self, iprot):
7987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7989 
      return
7990 
    iprot.readStructBegin()
7991 
    while True:
7992 
      (fname, ftype, fid) = iprot.readFieldBegin()
7993 
      if ftype == TType.STOP:
7994 
        break
7995 
      if fid == 1:
7996 
        if ftype == TType.I64:
3064 chandransh 7997 
          self.customerId = iprot.readI64();
1149 chandransh 7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      elif fid == 2:
8001 
        if ftype == TType.I64:
3064 chandransh 8002 
          self.from_date = iprot.readI64();
1149 chandransh 8003 
        else:
8004 
          iprot.skip(ftype)
2783 chandransh 8005 
      elif fid == 3:
8006 
        if ftype == TType.I64:
3064 chandransh 8007 
          self.to_date = iprot.readI64();
2783 chandransh 8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      elif fid == 4:
3064 chandransh 8011 
        if ftype == TType.LIST:
8012 
          self.statuses = []
4133 chandransh 8013 
          (_etype94, _size91) = iprot.readListBegin()
8014 
          for _i95 in xrange(_size91):
8015 
            _elem96 = iprot.readI32();
8016 
            self.statuses.append(_elem96)
3064 chandransh 8017 
          iprot.readListEnd()
2783 chandransh 8018 
        else:
8019 
          iprot.skip(ftype)
1149 chandransh 8020 
      else:
8021 
        iprot.skip(ftype)
8022 
      iprot.readFieldEnd()
8023 
    iprot.readStructEnd()
8024 
 
8025 
  def write(self, oprot):
8026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8028 
      return
3064 chandransh 8029 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8030 
    if self.customerId is not None:
3064 chandransh 8031 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8032 
      oprot.writeI64(self.customerId)
1149 chandransh 8033 
      oprot.writeFieldEnd()
3431 rajveer 8034 
    if self.from_date is not None:
3064 chandransh 8035 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8036 
      oprot.writeI64(self.from_date)
1149 chandransh 8037 
      oprot.writeFieldEnd()
3431 rajveer 8038 
    if self.to_date is not None:
3064 chandransh 8039 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8040 
      oprot.writeI64(self.to_date)
2783 chandransh 8041 
      oprot.writeFieldEnd()
3431 rajveer 8042 
    if self.statuses is not None:
3064 chandransh 8043 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8044 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8045 
      for iter97 in self.statuses:
8046 
        oprot.writeI32(iter97)
3064 chandransh 8047 
      oprot.writeListEnd()
2783 chandransh 8048 
      oprot.writeFieldEnd()
1149 chandransh 8049 
    oprot.writeFieldStop()
8050 
    oprot.writeStructEnd()
8051 
 
3431 rajveer 8052 
  def validate(self):
8053 
    return
8054 
 
8055 
 
1149 chandransh 8056 
  def __repr__(self):
8057 
    L = ['%s=%r' % (key, value)
8058 
      for key, value in self.__dict__.iteritems()]
8059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8060 
 
8061 
  def __eq__(self, other):
8062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8063 
 
8064 
  def __ne__(self, other):
8065 
    return not (self == other)
8066 
 
3064 chandransh 8067 
class getOrdersForCustomer_result:
1149 chandransh 8068 
  """
8069 
  Attributes:
8070 
   - success
8071 
   - ex
8072 
  """
8073 
 
8074 
  thrift_spec = (
3064 chandransh 8075 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8077 
  )
8078 
 
8079 
  def __init__(self, success=None, ex=None,):
8080 
    self.success = success
8081 
    self.ex = ex
8082 
 
8083 
  def read(self, iprot):
8084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8086 
      return
8087 
    iprot.readStructBegin()
8088 
    while True:
8089 
      (fname, ftype, fid) = iprot.readFieldBegin()
8090 
      if ftype == TType.STOP:
8091 
        break
8092 
      if fid == 0:
3064 chandransh 8093 
        if ftype == TType.LIST:
8094 
          self.success = []
4133 chandransh 8095 
          (_etype101, _size98) = iprot.readListBegin()
8096 
          for _i102 in xrange(_size98):
8097 
            _elem103 = Order()
8098 
            _elem103.read(iprot)
8099 
            self.success.append(_elem103)
3064 chandransh 8100 
          iprot.readListEnd()
1149 chandransh 8101 
        else:
8102 
          iprot.skip(ftype)
8103 
      elif fid == 1:
8104 
        if ftype == TType.STRUCT:
8105 
          self.ex = TransactionServiceException()
8106 
          self.ex.read(iprot)
8107 
        else:
8108 
          iprot.skip(ftype)
8109 
      else:
8110 
        iprot.skip(ftype)
8111 
      iprot.readFieldEnd()
8112 
    iprot.readStructEnd()
8113 
 
8114 
  def write(self, oprot):
8115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8117 
      return
3064 chandransh 8118 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8119 
    if self.success is not None:
3064 chandransh 8120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8121 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8122 
      for iter104 in self.success:
8123 
        iter104.write(oprot)
3064 chandransh 8124 
      oprot.writeListEnd()
1149 chandransh 8125 
      oprot.writeFieldEnd()
3431 rajveer 8126 
    if self.ex is not None:
1149 chandransh 8127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8128 
      self.ex.write(oprot)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
3431 rajveer 8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
1149 chandransh 8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
3064 chandransh 8148 
class createOrder_args:
921 rajveer 8149 
  """
8150 
  Attributes:
3064 chandransh 8151 
   - order
921 rajveer 8152 
  """
8153 
 
8154 
  thrift_spec = (
8155 
    None, # 0
3064 chandransh 8156 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8157 
  )
8158 
 
3064 chandransh 8159 
  def __init__(self, order=None,):
8160 
    self.order = order
921 rajveer 8161 
 
8162 
  def read(self, iprot):
8163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8165 
      return
8166 
    iprot.readStructBegin()
8167 
    while True:
8168 
      (fname, ftype, fid) = iprot.readFieldBegin()
8169 
      if ftype == TType.STOP:
8170 
        break
8171 
      if fid == 1:
3064 chandransh 8172 
        if ftype == TType.STRUCT:
8173 
          self.order = Order()
8174 
          self.order.read(iprot)
921 rajveer 8175 
        else:
8176 
          iprot.skip(ftype)
8177 
      else:
8178 
        iprot.skip(ftype)
8179 
      iprot.readFieldEnd()
8180 
    iprot.readStructEnd()
8181 
 
8182 
  def write(self, oprot):
8183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8185 
      return
3064 chandransh 8186 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8187 
    if self.order is not None:
3064 chandransh 8188 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8189 
      self.order.write(oprot)
921 rajveer 8190 
      oprot.writeFieldEnd()
8191 
    oprot.writeFieldStop()
8192 
    oprot.writeStructEnd()
8193 
 
3431 rajveer 8194 
  def validate(self):
8195 
    return
8196 
 
8197 
 
921 rajveer 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_result:
921 rajveer 8210 
  """
8211 
  Attributes:
8212 
   - success
8213 
   - ex
8214 
  """
8215 
 
8216 
  thrift_spec = (
3064 chandransh 8217 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8219 
  )
8220 
 
8221 
  def __init__(self, success=None, ex=None,):
8222 
    self.success = success
8223 
    self.ex = ex
8224 
 
8225 
  def read(self, iprot):
8226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8228 
      return
8229 
    iprot.readStructBegin()
8230 
    while True:
8231 
      (fname, ftype, fid) = iprot.readFieldBegin()
8232 
      if ftype == TType.STOP:
8233 
        break
8234 
      if fid == 0:
3064 chandransh 8235 
        if ftype == TType.I64:
8236 
          self.success = iprot.readI64();
921 rajveer 8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      elif fid == 1:
8240 
        if ftype == TType.STRUCT:
8241 
          self.ex = TransactionServiceException()
8242 
          self.ex.read(iprot)
8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      else:
8246 
        iprot.skip(ftype)
8247 
      iprot.readFieldEnd()
8248 
    iprot.readStructEnd()
8249 
 
8250 
  def write(self, oprot):
8251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8253 
      return
3064 chandransh 8254 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8255 
    if self.success is not None:
3064 chandransh 8256 
      oprot.writeFieldBegin('success', TType.I64, 0)
8257 
      oprot.writeI64(self.success)
921 rajveer 8258 
      oprot.writeFieldEnd()
3431 rajveer 8259 
    if self.ex is not None:
921 rajveer 8260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8261 
      self.ex.write(oprot)
8262 
      oprot.writeFieldEnd()
8263 
    oprot.writeFieldStop()
8264 
    oprot.writeStructEnd()
8265 
 
3431 rajveer 8266 
  def validate(self):
8267 
    return
8268 
 
8269 
 
921 rajveer 8270 
  def __repr__(self):
8271 
    L = ['%s=%r' % (key, value)
8272 
      for key, value in self.__dict__.iteritems()]
8273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8274 
 
8275 
  def __eq__(self, other):
8276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8277 
 
8278 
  def __ne__(self, other):
8279 
    return not (self == other)
8280 
 
3064 chandransh 8281 
class getOrder_args:
921 rajveer 8282 
  """
8283 
  Attributes:
3064 chandransh 8284 
   - id
921 rajveer 8285 
  """
8286 
 
8287 
  thrift_spec = (
8288 
    None, # 0
3064 chandransh 8289 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8290 
  )
8291 
 
3064 chandransh 8292 
  def __init__(self, id=None,):
8293 
    self.id = id
921 rajveer 8294 
 
8295 
  def read(self, iprot):
8296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8298 
      return
8299 
    iprot.readStructBegin()
8300 
    while True:
8301 
      (fname, ftype, fid) = iprot.readFieldBegin()
8302 
      if ftype == TType.STOP:
8303 
        break
8304 
      if fid == 1:
8305 
        if ftype == TType.I64:
3064 chandransh 8306 
          self.id = iprot.readI64();
921 rajveer 8307 
        else:
8308 
          iprot.skip(ftype)
8309 
      else:
8310 
        iprot.skip(ftype)
8311 
      iprot.readFieldEnd()
8312 
    iprot.readStructEnd()
8313 
 
8314 
  def write(self, oprot):
8315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8317 
      return
3064 chandransh 8318 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8319 
    if self.id is not None:
3064 chandransh 8320 
      oprot.writeFieldBegin('id', TType.I64, 1)
8321 
      oprot.writeI64(self.id)
921 rajveer 8322 
      oprot.writeFieldEnd()
8323 
    oprot.writeFieldStop()
8324 
    oprot.writeStructEnd()
8325 
 
3431 rajveer 8326 
  def validate(self):
8327 
    return
8328 
 
8329 
 
921 rajveer 8330 
  def __repr__(self):
8331 
    L = ['%s=%r' % (key, value)
8332 
      for key, value in self.__dict__.iteritems()]
8333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8334 
 
8335 
  def __eq__(self, other):
8336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8337 
 
8338 
  def __ne__(self, other):
8339 
    return not (self == other)
8340 
 
3064 chandransh 8341 
class getOrder_result:
921 rajveer 8342 
  """
8343 
  Attributes:
8344 
   - success
8345 
   - ex
8346 
  """
8347 
 
8348 
  thrift_spec = (
3064 chandransh 8349 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8351 
  )
8352 
 
8353 
  def __init__(self, success=None, ex=None,):
8354 
    self.success = success
8355 
    self.ex = ex
8356 
 
8357 
  def read(self, iprot):
8358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8360 
      return
8361 
    iprot.readStructBegin()
8362 
    while True:
8363 
      (fname, ftype, fid) = iprot.readFieldBegin()
8364 
      if ftype == TType.STOP:
8365 
        break
8366 
      if fid == 0:
3064 chandransh 8367 
        if ftype == TType.STRUCT:
8368 
          self.success = Order()
8369 
          self.success.read(iprot)
921 rajveer 8370 
        else:
8371 
          iprot.skip(ftype)
8372 
      elif fid == 1:
8373 
        if ftype == TType.STRUCT:
8374 
          self.ex = TransactionServiceException()
8375 
          self.ex.read(iprot)
8376 
        else:
8377 
          iprot.skip(ftype)
8378 
      else:
8379 
        iprot.skip(ftype)
8380 
      iprot.readFieldEnd()
8381 
    iprot.readStructEnd()
8382 
 
8383 
  def write(self, oprot):
8384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8386 
      return
3064 chandransh 8387 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8388 
    if self.success is not None:
3064 chandransh 8389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8390 
      self.success.write(oprot)
921 rajveer 8391 
      oprot.writeFieldEnd()
3431 rajveer 8392 
    if self.ex is not None:
921 rajveer 8393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8394 
      self.ex.write(oprot)
8395 
      oprot.writeFieldEnd()
8396 
    oprot.writeFieldStop()
8397 
    oprot.writeStructEnd()
8398 
 
3431 rajveer 8399 
  def validate(self):
8400 
    return
8401 
 
8402 
 
921 rajveer 8403 
  def __repr__(self):
8404 
    L = ['%s=%r' % (key, value)
8405 
      for key, value in self.__dict__.iteritems()]
8406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8407 
 
8408 
  def __eq__(self, other):
8409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8410 
 
8411 
  def __ne__(self, other):
8412 
    return not (self == other)
8413 
 
3064 chandransh 8414 
class getLineItemsForOrder_args:
94 ashish 8415 
  """
8416 
  Attributes:
3064 chandransh 8417 
   - orderId
94 ashish 8418 
  """
8419 
 
8420 
  thrift_spec = (
8421 
    None, # 0
3064 chandransh 8422 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8423 
  )
8424 
 
3064 chandransh 8425 
  def __init__(self, orderId=None,):
8426 
    self.orderId = orderId
94 ashish 8427 
 
8428 
  def read(self, iprot):
8429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8431 
      return
8432 
    iprot.readStructBegin()
8433 
    while True:
8434 
      (fname, ftype, fid) = iprot.readFieldBegin()
8435 
      if ftype == TType.STOP:
8436 
        break
8437 
      if fid == 1:
8438 
        if ftype == TType.I64:
3064 chandransh 8439 
          self.orderId = iprot.readI64();
94 ashish 8440 
        else:
8441 
          iprot.skip(ftype)
8442 
      else:
8443 
        iprot.skip(ftype)
8444 
      iprot.readFieldEnd()
8445 
    iprot.readStructEnd()
8446 
 
8447 
  def write(self, oprot):
8448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8450 
      return
3064 chandransh 8451 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8452 
    if self.orderId is not None:
3064 chandransh 8453 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8454 
      oprot.writeI64(self.orderId)
94 ashish 8455 
      oprot.writeFieldEnd()
8456 
    oprot.writeFieldStop()
8457 
    oprot.writeStructEnd()
8458 
 
3431 rajveer 8459 
  def validate(self):
8460 
    return
8461 
 
8462 
 
94 ashish 8463 
  def __repr__(self):
8464 
    L = ['%s=%r' % (key, value)
8465 
      for key, value in self.__dict__.iteritems()]
8466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8467 
 
8468 
  def __eq__(self, other):
8469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8470 
 
8471 
  def __ne__(self, other):
8472 
    return not (self == other)
8473 
 
3064 chandransh 8474 
class getLineItemsForOrder_result:
94 ashish 8475 
  """
8476 
  Attributes:
8477 
   - success
8478 
   - ex
8479 
  """
8480 
 
8481 
  thrift_spec = (
3064 chandransh 8482 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8484 
  )
8485 
 
8486 
  def __init__(self, success=None, ex=None,):
8487 
    self.success = success
8488 
    self.ex = ex
8489 
 
8490 
  def read(self, iprot):
8491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8493 
      return
8494 
    iprot.readStructBegin()
8495 
    while True:
8496 
      (fname, ftype, fid) = iprot.readFieldBegin()
8497 
      if ftype == TType.STOP:
8498 
        break
8499 
      if fid == 0:
483 rajveer 8500 
        if ftype == TType.LIST:
8501 
          self.success = []
4133 chandransh 8502 
          (_etype108, _size105) = iprot.readListBegin()
8503 
          for _i109 in xrange(_size105):
8504 
            _elem110 = LineItem()
8505 
            _elem110.read(iprot)
8506 
            self.success.append(_elem110)
483 rajveer 8507 
          iprot.readListEnd()
94 ashish 8508 
        else:
8509 
          iprot.skip(ftype)
8510 
      elif fid == 1:
8511 
        if ftype == TType.STRUCT:
8512 
          self.ex = TransactionServiceException()
8513 
          self.ex.read(iprot)
8514 
        else:
8515 
          iprot.skip(ftype)
8516 
      else:
8517 
        iprot.skip(ftype)
8518 
      iprot.readFieldEnd()
8519 
    iprot.readStructEnd()
8520 
 
8521 
  def write(self, oprot):
8522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8524 
      return
3064 chandransh 8525 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8526 
    if self.success is not None:
483 rajveer 8527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8529 
      for iter111 in self.success:
8530 
        iter111.write(oprot)
483 rajveer 8531 
      oprot.writeListEnd()
94 ashish 8532 
      oprot.writeFieldEnd()
3431 rajveer 8533 
    if self.ex is not None:
94 ashish 8534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8535 
      self.ex.write(oprot)
8536 
      oprot.writeFieldEnd()
8537 
    oprot.writeFieldStop()
8538 
    oprot.writeStructEnd()
8539 
 
3431 rajveer 8540 
  def validate(self):
8541 
    return
8542 
 
8543 
 
94 ashish 8544 
  def __repr__(self):
8545 
    L = ['%s=%r' % (key, value)
8546 
      for key, value in self.__dict__.iteritems()]
8547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8548 
 
8549 
  def __eq__(self, other):
8550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8551 
 
8552 
  def __ne__(self, other):
8553 
    return not (self == other)
8554 
 
3064 chandransh 8555 
class getOrderForCustomer_args:
94 ashish 8556 
  """
8557 
  Attributes:
3064 chandransh 8558 
   - orderId
483 rajveer 8559 
   - customerId
94 ashish 8560 
  """
8561 
 
8562 
  thrift_spec = (
8563 
    None, # 0
3064 chandransh 8564 
    (1, TType.I64, 'orderId', None, None, ), # 1
8565 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8566 
  )
8567 
 
3064 chandransh 8568 
  def __init__(self, orderId=None, customerId=None,):
8569 
    self.orderId = orderId
483 rajveer 8570 
    self.customerId = customerId
94 ashish 8571 
 
8572 
  def read(self, iprot):
8573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8575 
      return
8576 
    iprot.readStructBegin()
8577 
    while True:
8578 
      (fname, ftype, fid) = iprot.readFieldBegin()
8579 
      if ftype == TType.STOP:
8580 
        break
8581 
      if fid == 1:
8582 
        if ftype == TType.I64:
3064 chandransh 8583 
          self.orderId = iprot.readI64();
94 ashish 8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      elif fid == 2:
8587 
        if ftype == TType.I64:
3064 chandransh 8588 
          self.customerId = iprot.readI64();
94 ashish 8589 
        else:
8590 
          iprot.skip(ftype)
8591 
      else:
8592 
        iprot.skip(ftype)
8593 
      iprot.readFieldEnd()
8594 
    iprot.readStructEnd()
8595 
 
8596 
  def write(self, oprot):
8597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8599 
      return
3064 chandransh 8600 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8601 
    if self.orderId is not None:
3064 chandransh 8602 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8603 
      oprot.writeI64(self.orderId)
8604 
      oprot.writeFieldEnd()
3431 rajveer 8605 
    if self.customerId is not None:
3064 chandransh 8606 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8607 
      oprot.writeI64(self.customerId)
94 ashish 8608 
      oprot.writeFieldEnd()
8609 
    oprot.writeFieldStop()
8610 
    oprot.writeStructEnd()
8611 
 
3431 rajveer 8612 
  def validate(self):
8613 
    return
8614 
 
8615 
 
94 ashish 8616 
  def __repr__(self):
8617 
    L = ['%s=%r' % (key, value)
8618 
      for key, value in self.__dict__.iteritems()]
8619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8620 
 
8621 
  def __eq__(self, other):
8622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8623 
 
8624 
  def __ne__(self, other):
8625 
    return not (self == other)
8626 
 
3064 chandransh 8627 
class getOrderForCustomer_result:
94 ashish 8628 
  """
8629 
  Attributes:
8630 
   - success
8631 
   - ex
8632 
  """
8633 
 
8634 
  thrift_spec = (
3064 chandransh 8635 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8637 
  )
8638 
 
8639 
  def __init__(self, success=None, ex=None,):
8640 
    self.success = success
8641 
    self.ex = ex
8642 
 
8643 
  def read(self, iprot):
8644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8646 
      return
8647 
    iprot.readStructBegin()
8648 
    while True:
8649 
      (fname, ftype, fid) = iprot.readFieldBegin()
8650 
      if ftype == TType.STOP:
8651 
        break
8652 
      if fid == 0:
3064 chandransh 8653 
        if ftype == TType.STRUCT:
8654 
          self.success = Order()
8655 
          self.success.read(iprot)
94 ashish 8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      elif fid == 1:
8659 
        if ftype == TType.STRUCT:
8660 
          self.ex = TransactionServiceException()
8661 
          self.ex.read(iprot)
8662 
        else:
8663 
          iprot.skip(ftype)
8664 
      else:
8665 
        iprot.skip(ftype)
8666 
      iprot.readFieldEnd()
8667 
    iprot.readStructEnd()
8668 
 
8669 
  def write(self, oprot):
8670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8672 
      return
3064 chandransh 8673 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8674 
    if self.success is not None:
3064 chandransh 8675 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8676 
      self.success.write(oprot)
94 ashish 8677 
      oprot.writeFieldEnd()
3431 rajveer 8678 
    if self.ex is not None:
94 ashish 8679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8680 
      self.ex.write(oprot)
8681 
      oprot.writeFieldEnd()
8682 
    oprot.writeFieldStop()
8683 
    oprot.writeStructEnd()
8684 
 
3431 rajveer 8685 
  def validate(self):
8686 
    return
8687 
 
8688 
 
94 ashish 8689 
  def __repr__(self):
8690 
    L = ['%s=%r' % (key, value)
8691 
      for key, value in self.__dict__.iteritems()]
8692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8693 
 
8694 
  def __eq__(self, other):
8695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8696 
 
8697 
  def __ne__(self, other):
8698 
    return not (self == other)
8699 
 
3064 chandransh 8700 
class getAlerts_args:
94 ashish 8701 
  """
8702 
  Attributes:
4394 rajveer 8703 
   - type
4444 rajveer 8704 
   - warehouseId
4394 rajveer 8705 
   - status
8706 
   - timestamp
94 ashish 8707 
  """
8708 
 
8709 
  thrift_spec = (
8710 
    None, # 0
4394 rajveer 8711 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8712 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8713 
    (3, TType.I64, 'status', None, None, ), # 3
8714 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8715 
  )
8716 
 
4444 rajveer 8717 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8718 
    self.type = type
4444 rajveer 8719 
    self.warehouseId = warehouseId
4394 rajveer 8720 
    self.status = status
8721 
    self.timestamp = timestamp
94 ashish 8722 
 
8723 
  def read(self, iprot):
8724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8726 
      return
8727 
    iprot.readStructBegin()
8728 
    while True:
8729 
      (fname, ftype, fid) = iprot.readFieldBegin()
8730 
      if ftype == TType.STOP:
8731 
        break
8732 
      if fid == 1:
3064 chandransh 8733 
        if ftype == TType.I64:
4394 rajveer 8734 
          self.type = iprot.readI64();
94 ashish 8735 
        else:
8736 
          iprot.skip(ftype)
3064 chandransh 8737 
      elif fid == 2:
4394 rajveer 8738 
        if ftype == TType.I64:
4444 rajveer 8739 
          self.warehouseId = iprot.readI64();
3064 chandransh 8740 
        else:
8741 
          iprot.skip(ftype)
4394 rajveer 8742 
      elif fid == 3:
8743 
        if ftype == TType.I64:
4444 rajveer 8744 
          self.status = iprot.readI64();
8745 
        else:
8746 
          iprot.skip(ftype)
8747 
      elif fid == 4:
8748 
        if ftype == TType.I64:
4394 rajveer 8749 
          self.timestamp = iprot.readI64();
8750 
        else:
8751 
          iprot.skip(ftype)
94 ashish 8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
3064 chandransh 8761 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8762 
    if self.type is not None:
8763 
      oprot.writeFieldBegin('type', TType.I64, 1)
8764 
      oprot.writeI64(self.type)
94 ashish 8765 
      oprot.writeFieldEnd()
4444 rajveer 8766 
    if self.warehouseId is not None:
8767 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8768 
      oprot.writeI64(self.warehouseId)
8769 
      oprot.writeFieldEnd()
4394 rajveer 8770 
    if self.status is not None:
4444 rajveer 8771 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8772 
      oprot.writeI64(self.status)
3064 chandransh 8773 
      oprot.writeFieldEnd()
4394 rajveer 8774 
    if self.timestamp is not None:
4444 rajveer 8775 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8776 
      oprot.writeI64(self.timestamp)
8777 
      oprot.writeFieldEnd()
94 ashish 8778 
    oprot.writeFieldStop()
8779 
    oprot.writeStructEnd()
8780 
 
3431 rajveer 8781 
  def validate(self):
8782 
    return
8783 
 
8784 
 
94 ashish 8785 
  def __repr__(self):
8786 
    L = ['%s=%r' % (key, value)
8787 
      for key, value in self.__dict__.iteritems()]
8788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8789 
 
8790 
  def __eq__(self, other):
8791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8792 
 
8793 
  def __ne__(self, other):
8794 
    return not (self == other)
8795 
 
3064 chandransh 8796 
class getAlerts_result:
94 ashish 8797 
  """
8798 
  Attributes:
8799 
   - success
8800 
  """
8801 
 
8802 
  thrift_spec = (
3064 chandransh 8803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8804 
  )
8805 
 
3064 chandransh 8806 
  def __init__(self, success=None,):
94 ashish 8807 
    self.success = success
8808 
 
8809 
  def read(self, iprot):
8810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8812 
      return
8813 
    iprot.readStructBegin()
8814 
    while True:
8815 
      (fname, ftype, fid) = iprot.readFieldBegin()
8816 
      if ftype == TType.STOP:
8817 
        break
8818 
      if fid == 0:
3064 chandransh 8819 
        if ftype == TType.LIST:
8820 
          self.success = []
4133 chandransh 8821 
          (_etype115, _size112) = iprot.readListBegin()
8822 
          for _i116 in xrange(_size112):
8823 
            _elem117 = Alert()
8824 
            _elem117.read(iprot)
8825 
            self.success.append(_elem117)
3064 chandransh 8826 
          iprot.readListEnd()
94 ashish 8827 
        else:
8828 
          iprot.skip(ftype)
8829 
      else:
8830 
        iprot.skip(ftype)
8831 
      iprot.readFieldEnd()
8832 
    iprot.readStructEnd()
8833 
 
8834 
  def write(self, oprot):
8835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8837 
      return
3064 chandransh 8838 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8839 
    if self.success is not None:
3064 chandransh 8840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8842 
      for iter118 in self.success:
8843 
        iter118.write(oprot)
3064 chandransh 8844 
      oprot.writeListEnd()
94 ashish 8845 
      oprot.writeFieldEnd()
8846 
    oprot.writeFieldStop()
8847 
    oprot.writeStructEnd()
8848 
 
3431 rajveer 8849 
  def validate(self):
8850 
    return
8851 
 
8852 
 
94 ashish 8853 
  def __repr__(self):
8854 
    L = ['%s=%r' % (key, value)
8855 
      for key, value in self.__dict__.iteritems()]
8856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8857 
 
8858 
  def __eq__(self, other):
8859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8860 
 
8861 
  def __ne__(self, other):
8862 
    return not (self == other)
8863 
 
4394 rajveer 8864 
class addAlert_args:
94 ashish 8865 
  """
8866 
  Attributes:
3064 chandransh 8867 
   - type
4444 rajveer 8868 
   - warehouseId
4394 rajveer 8869 
   - description
94 ashish 8870 
  """
8871 
 
8872 
  thrift_spec = (
8873 
    None, # 0
4394 rajveer 8874 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8875 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8876 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8877 
  )
8878 
 
4444 rajveer 8879 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8880 
    self.type = type
4444 rajveer 8881 
    self.warehouseId = warehouseId
4394 rajveer 8882 
    self.description = description
94 ashish 8883 
 
8884 
  def read(self, iprot):
8885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8887 
      return
8888 
    iprot.readStructBegin()
8889 
    while True:
8890 
      (fname, ftype, fid) = iprot.readFieldBegin()
8891 
      if ftype == TType.STOP:
8892 
        break
8893 
      if fid == 1:
8894 
        if ftype == TType.I64:
4394 rajveer 8895 
          self.type = iprot.readI64();
94 ashish 8896 
        else:
8897 
          iprot.skip(ftype)
3064 chandransh 8898 
      elif fid == 2:
4444 rajveer 8899 
        if ftype == TType.I64:
8900 
          self.warehouseId = iprot.readI64();
8901 
        else:
8902 
          iprot.skip(ftype)
8903 
      elif fid == 3:
3064 chandransh 8904 
        if ftype == TType.STRING:
4394 rajveer 8905 
          self.description = iprot.readString();
3064 chandransh 8906 
        else:
8907 
          iprot.skip(ftype)
94 ashish 8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
4394 rajveer 8917 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8918 
    if self.type is not None:
4394 rajveer 8919 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8920 
      oprot.writeI64(self.type)
8921 
      oprot.writeFieldEnd()
4444 rajveer 8922 
    if self.warehouseId is not None:
8923 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8924 
      oprot.writeI64(self.warehouseId)
8925 
      oprot.writeFieldEnd()
4394 rajveer 8926 
    if self.description is not None:
4444 rajveer 8927 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8928 
      oprot.writeString(self.description)
3064 chandransh 8929 
      oprot.writeFieldEnd()
94 ashish 8930 
    oprot.writeFieldStop()
8931 
    oprot.writeStructEnd()
8932 
 
3431 rajveer 8933 
  def validate(self):
8934 
    return
8935 
 
8936 
 
94 ashish 8937 
  def __repr__(self):
8938 
    L = ['%s=%r' % (key, value)
8939 
      for key, value in self.__dict__.iteritems()]
8940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8941 
 
8942 
  def __eq__(self, other):
8943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8944 
 
8945 
  def __ne__(self, other):
8946 
    return not (self == other)
8947 
 
4394 rajveer 8948 
class addAlert_result:
3064 chandransh 8949 
 
8950 
  thrift_spec = (
8951 
  )
8952 
 
8953 
  def read(self, iprot):
8954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8956 
      return
8957 
    iprot.readStructBegin()
8958 
    while True:
8959 
      (fname, ftype, fid) = iprot.readFieldBegin()
8960 
      if ftype == TType.STOP:
8961 
        break
8962 
      else:
8963 
        iprot.skip(ftype)
8964 
      iprot.readFieldEnd()
8965 
    iprot.readStructEnd()
8966 
 
8967 
  def write(self, oprot):
8968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8970 
      return
4394 rajveer 8971 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8972 
    oprot.writeFieldStop()
8973 
    oprot.writeStructEnd()
8974 
 
3431 rajveer 8975 
  def validate(self):
8976 
    return
8977 
 
8978 
 
3064 chandransh 8979 
  def __repr__(self):
8980 
    L = ['%s=%r' % (key, value)
8981 
      for key, value in self.__dict__.iteritems()]
8982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8983 
 
8984 
  def __eq__(self, other):
8985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8986 
 
8987 
  def __ne__(self, other):
8988 
    return not (self == other)
8989 
 
4444 rajveer 8990 
class markAlertsAsSeen_args:
8991 
  """
8992 
  Attributes:
8993 
   - warehouseId
8994 
  """
8995 
 
8996 
  thrift_spec = (
8997 
    None, # 0
8998 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8999 
  )
9000 
 
9001 
  def __init__(self, warehouseId=None,):
9002 
    self.warehouseId = warehouseId
9003 
 
9004 
  def read(self, iprot):
9005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9007 
      return
9008 
    iprot.readStructBegin()
9009 
    while True:
9010 
      (fname, ftype, fid) = iprot.readFieldBegin()
9011 
      if ftype == TType.STOP:
9012 
        break
9013 
      if fid == 1:
9014 
        if ftype == TType.I64:
9015 
          self.warehouseId = iprot.readI64();
9016 
        else:
9017 
          iprot.skip(ftype)
9018 
      else:
9019 
        iprot.skip(ftype)
9020 
      iprot.readFieldEnd()
9021 
    iprot.readStructEnd()
9022 
 
9023 
  def write(self, oprot):
9024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9026 
      return
9027 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9028 
    if self.warehouseId is not None:
9029 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9030 
      oprot.writeI64(self.warehouseId)
9031 
      oprot.writeFieldEnd()
9032 
    oprot.writeFieldStop()
9033 
    oprot.writeStructEnd()
9034 
 
9035 
  def validate(self):
9036 
    return
9037 
 
9038 
 
9039 
  def __repr__(self):
9040 
    L = ['%s=%r' % (key, value)
9041 
      for key, value in self.__dict__.iteritems()]
9042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9043 
 
9044 
  def __eq__(self, other):
9045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9046 
 
9047 
  def __ne__(self, other):
9048 
    return not (self == other)
9049 
 
9050 
class markAlertsAsSeen_result:
9051 
 
9052 
  thrift_spec = (
9053 
  )
9054 
 
9055 
  def read(self, iprot):
9056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9058 
      return
9059 
    iprot.readStructBegin()
9060 
    while True:
9061 
      (fname, ftype, fid) = iprot.readFieldBegin()
9062 
      if ftype == TType.STOP:
9063 
        break
9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
9073 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9074 
    oprot.writeFieldStop()
9075 
    oprot.writeStructEnd()
9076 
 
9077 
  def validate(self):
9078 
    return
9079 
 
9080 
 
9081 
  def __repr__(self):
9082 
    L = ['%s=%r' % (key, value)
9083 
      for key, value in self.__dict__.iteritems()]
9084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9085 
 
9086 
  def __eq__(self, other):
9087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9088 
 
9089 
  def __ne__(self, other):
9090 
    return not (self == other)
9091 
 
3064 chandransh 9092 
class getValidOrderCount_args:
9093 
 
9094 
  thrift_spec = (
9095 
  )
9096 
 
9097 
  def read(self, iprot):
9098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9100 
      return
9101 
    iprot.readStructBegin()
9102 
    while True:
9103 
      (fname, ftype, fid) = iprot.readFieldBegin()
9104 
      if ftype == TType.STOP:
9105 
        break
9106 
      else:
9107 
        iprot.skip(ftype)
9108 
      iprot.readFieldEnd()
9109 
    iprot.readStructEnd()
9110 
 
9111 
  def write(self, oprot):
9112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9114 
      return
9115 
    oprot.writeStructBegin('getValidOrderCount_args')
9116 
    oprot.writeFieldStop()
9117 
    oprot.writeStructEnd()
9118 
 
3431 rajveer 9119 
  def validate(self):
9120 
    return
9121 
 
9122 
 
3064 chandransh 9123 
  def __repr__(self):
9124 
    L = ['%s=%r' % (key, value)
9125 
      for key, value in self.__dict__.iteritems()]
9126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9127 
 
9128 
  def __eq__(self, other):
9129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9130 
 
9131 
  def __ne__(self, other):
9132 
    return not (self == other)
9133 
 
9134 
class getValidOrderCount_result:
94 ashish 9135 
  """
9136 
  Attributes:
9137 
   - success
9138 
  """
9139 
 
9140 
  thrift_spec = (
3064 chandransh 9141 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9142 
  )
9143 
 
3064 chandransh 9144 
  def __init__(self, success=None,):
94 ashish 9145 
    self.success = success
9146 
 
9147 
  def read(self, iprot):
9148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9150 
      return
9151 
    iprot.readStructBegin()
9152 
    while True:
9153 
      (fname, ftype, fid) = iprot.readFieldBegin()
9154 
      if ftype == TType.STOP:
9155 
        break
9156 
      if fid == 0:
3064 chandransh 9157 
        if ftype == TType.I64:
9158 
          self.success = iprot.readI64();
94 ashish 9159 
        else:
9160 
          iprot.skip(ftype)
9161 
      else:
9162 
        iprot.skip(ftype)
9163 
      iprot.readFieldEnd()
9164 
    iprot.readStructEnd()
9165 
 
9166 
  def write(self, oprot):
9167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9169 
      return
3064 chandransh 9170 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9171 
    if self.success is not None:
3064 chandransh 9172 
      oprot.writeFieldBegin('success', TType.I64, 0)
9173 
      oprot.writeI64(self.success)
94 ashish 9174 
      oprot.writeFieldEnd()
9175 
    oprot.writeFieldStop()
9176 
    oprot.writeStructEnd()
9177 
 
3431 rajveer 9178 
  def validate(self):
9179 
    return
9180 
 
9181 
 
94 ashish 9182 
  def __repr__(self):
9183 
    L = ['%s=%r' % (key, value)
9184 
      for key, value in self.__dict__.iteritems()]
9185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9186 
 
9187 
  def __eq__(self, other):
9188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9189 
 
9190 
  def __ne__(self, other):
9191 
    return not (self == other)
9192 
 
3064 chandransh 9193 
class getNoOfCustomersWithSuccessfulTransaction_args:
9194 
 
9195 
  thrift_spec = (
9196 
  )
9197 
 
9198 
  def read(self, iprot):
9199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9201 
      return
9202 
    iprot.readStructBegin()
9203 
    while True:
9204 
      (fname, ftype, fid) = iprot.readFieldBegin()
9205 
      if ftype == TType.STOP:
9206 
        break
9207 
      else:
9208 
        iprot.skip(ftype)
9209 
      iprot.readFieldEnd()
9210 
    iprot.readStructEnd()
9211 
 
9212 
  def write(self, oprot):
9213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9215 
      return
9216 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9217 
    oprot.writeFieldStop()
9218 
    oprot.writeStructEnd()
9219 
 
3431 rajveer 9220 
  def validate(self):
9221 
    return
9222 
 
9223 
 
3064 chandransh 9224 
  def __repr__(self):
9225 
    L = ['%s=%r' % (key, value)
9226 
      for key, value in self.__dict__.iteritems()]
9227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9228 
 
9229 
  def __eq__(self, other):
9230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9231 
 
9232 
  def __ne__(self, other):
9233 
    return not (self == other)
9234 
 
9235 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9236 
  """
9237 
  Attributes:
3064 chandransh 9238 
   - success
94 ashish 9239 
  """
9240 
 
9241 
  thrift_spec = (
3064 chandransh 9242 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9243 
  )
9244 
 
3064 chandransh 9245 
  def __init__(self, success=None,):
9246 
    self.success = success
94 ashish 9247 
 
9248 
  def read(self, iprot):
9249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9251 
      return
9252 
    iprot.readStructBegin()
9253 
    while True:
9254 
      (fname, ftype, fid) = iprot.readFieldBegin()
9255 
      if ftype == TType.STOP:
9256 
        break
3064 chandransh 9257 
      if fid == 0:
94 ashish 9258 
        if ftype == TType.I64:
3064 chandransh 9259 
          self.success = iprot.readI64();
94 ashish 9260 
        else:
9261 
          iprot.skip(ftype)
9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
3064 chandransh 9271 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9272 
    if self.success is not None:
3064 chandransh 9273 
      oprot.writeFieldBegin('success', TType.I64, 0)
9274 
      oprot.writeI64(self.success)
94 ashish 9275 
      oprot.writeFieldEnd()
9276 
    oprot.writeFieldStop()
9277 
    oprot.writeStructEnd()
9278 
 
3431 rajveer 9279 
  def validate(self):
9280 
    return
9281 
 
9282 
 
94 ashish 9283 
  def __repr__(self):
9284 
    L = ['%s=%r' % (key, value)
9285 
      for key, value in self.__dict__.iteritems()]
9286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9287 
 
9288 
  def __eq__(self, other):
9289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9290 
 
9291 
  def __ne__(self, other):
9292 
    return not (self == other)
9293 
 
3064 chandransh 9294 
class getValidOrdersAmountRange_args:
9295 
 
9296 
  thrift_spec = (
9297 
  )
9298 
 
9299 
  def read(self, iprot):
9300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9302 
      return
9303 
    iprot.readStructBegin()
9304 
    while True:
9305 
      (fname, ftype, fid) = iprot.readFieldBegin()
9306 
      if ftype == TType.STOP:
9307 
        break
9308 
      else:
9309 
        iprot.skip(ftype)
9310 
      iprot.readFieldEnd()
9311 
    iprot.readStructEnd()
9312 
 
9313 
  def write(self, oprot):
9314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9316 
      return
9317 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9318 
    oprot.writeFieldStop()
9319 
    oprot.writeStructEnd()
9320 
 
3431 rajveer 9321 
  def validate(self):
9322 
    return
9323 
 
9324 
 
3064 chandransh 9325 
  def __repr__(self):
9326 
    L = ['%s=%r' % (key, value)
9327 
      for key, value in self.__dict__.iteritems()]
9328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9329 
 
9330 
  def __eq__(self, other):
9331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9332 
 
9333 
  def __ne__(self, other):
9334 
    return not (self == other)
9335 
 
9336 
class getValidOrdersAmountRange_result:
94 ashish 9337 
  """
9338 
  Attributes:
9339 
   - success
9340 
  """
9341 
 
9342 
  thrift_spec = (
3064 chandransh 9343 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9344 
  )
9345 
 
3064 chandransh 9346 
  def __init__(self, success=None,):
94 ashish 9347 
    self.success = success
9348 
 
9349 
  def read(self, iprot):
9350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9352 
      return
9353 
    iprot.readStructBegin()
9354 
    while True:
9355 
      (fname, ftype, fid) = iprot.readFieldBegin()
9356 
      if ftype == TType.STOP:
9357 
        break
9358 
      if fid == 0:
483 rajveer 9359 
        if ftype == TType.LIST:
9360 
          self.success = []
4133 chandransh 9361 
          (_etype122, _size119) = iprot.readListBegin()
9362 
          for _i123 in xrange(_size119):
9363 
            _elem124 = iprot.readDouble();
9364 
            self.success.append(_elem124)
483 rajveer 9365 
          iprot.readListEnd()
94 ashish 9366 
        else:
9367 
          iprot.skip(ftype)
9368 
      else:
9369 
        iprot.skip(ftype)
9370 
      iprot.readFieldEnd()
9371 
    iprot.readStructEnd()
9372 
 
9373 
  def write(self, oprot):
9374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9376 
      return
3064 chandransh 9377 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9378 
    if self.success is not None:
483 rajveer 9379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9380 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9381 
      for iter125 in self.success:
9382 
        oprot.writeDouble(iter125)
483 rajveer 9383 
      oprot.writeListEnd()
94 ashish 9384 
      oprot.writeFieldEnd()
9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
94 ashish 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
3064 chandransh 9403 
class getValidOrders_args:
1528 ankur.sing 9404 
  """
9405 
  Attributes:
3064 chandransh 9406 
   - limit
1528 ankur.sing 9407 
  """
9408 
 
9409 
  thrift_spec = (
9410 
    None, # 0
3064 chandransh 9411 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9412 
  )
9413 
 
3064 chandransh 9414 
  def __init__(self, limit=None,):
9415 
    self.limit = limit
1528 ankur.sing 9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
3064 chandransh 9428 
          self.limit = iprot.readI64();
1528 ankur.sing 9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      else:
9432 
        iprot.skip(ftype)
9433 
      iprot.readFieldEnd()
9434 
    iprot.readStructEnd()
9435 
 
9436 
  def write(self, oprot):
9437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9439 
      return
3064 chandransh 9440 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9441 
    if self.limit is not None:
3064 chandransh 9442 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9443 
      oprot.writeI64(self.limit)
1528 ankur.sing 9444 
      oprot.writeFieldEnd()
9445 
    oprot.writeFieldStop()
9446 
    oprot.writeStructEnd()
9447 
 
3431 rajveer 9448 
  def validate(self):
9449 
    return
9450 
 
9451 
 
1528 ankur.sing 9452 
  def __repr__(self):
9453 
    L = ['%s=%r' % (key, value)
9454 
      for key, value in self.__dict__.iteritems()]
9455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9456 
 
9457 
  def __eq__(self, other):
9458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9459 
 
9460 
  def __ne__(self, other):
9461 
    return not (self == other)
9462 
 
3064 chandransh 9463 
class getValidOrders_result:
1528 ankur.sing 9464 
  """
9465 
  Attributes:
9466 
   - success
9467 
  """
9468 
 
9469 
  thrift_spec = (
3064 chandransh 9470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9471 
  )
9472 
 
3064 chandransh 9473 
  def __init__(self, success=None,):
1528 ankur.sing 9474 
    self.success = success
9475 
 
9476 
  def read(self, iprot):
9477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9479 
      return
9480 
    iprot.readStructBegin()
9481 
    while True:
9482 
      (fname, ftype, fid) = iprot.readFieldBegin()
9483 
      if ftype == TType.STOP:
9484 
        break
9485 
      if fid == 0:
3064 chandransh 9486 
        if ftype == TType.LIST:
9487 
          self.success = []
4133 chandransh 9488 
          (_etype129, _size126) = iprot.readListBegin()
9489 
          for _i130 in xrange(_size126):
9490 
            _elem131 = Order()
9491 
            _elem131.read(iprot)
9492 
            self.success.append(_elem131)
3064 chandransh 9493 
          iprot.readListEnd()
1528 ankur.sing 9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      else:
9497 
        iprot.skip(ftype)
9498 
      iprot.readFieldEnd()
9499 
    iprot.readStructEnd()
9500 
 
9501 
  def write(self, oprot):
9502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9504 
      return
3064 chandransh 9505 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9506 
    if self.success is not None:
3064 chandransh 9507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9509 
      for iter132 in self.success:
9510 
        iter132.write(oprot)
3064 chandransh 9511 
      oprot.writeListEnd()
1528 ankur.sing 9512 
      oprot.writeFieldEnd()
9513 
    oprot.writeFieldStop()
9514 
    oprot.writeStructEnd()
9515 
 
3431 rajveer 9516 
  def validate(self):
9517 
    return
9518 
 
9519 
 
1528 ankur.sing 9520 
  def __repr__(self):
9521 
    L = ['%s=%r' % (key, value)
9522 
      for key, value in self.__dict__.iteritems()]
9523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9524 
 
9525 
  def __eq__(self, other):
9526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9527 
 
9528 
  def __ne__(self, other):
9529 
    return not (self == other)
9530 
 
1220 chandransh 9531 
class batchOrders_args:
9532 
  """
9533 
  Attributes:
9534 
   - warehouseId
9535 
  """
9536 
 
9537 
  thrift_spec = (
9538 
    None, # 0
9539 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9540 
  )
9541 
 
9542 
  def __init__(self, warehouseId=None,):
9543 
    self.warehouseId = warehouseId
9544 
 
9545 
  def read(self, iprot):
9546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9548 
      return
9549 
    iprot.readStructBegin()
9550 
    while True:
9551 
      (fname, ftype, fid) = iprot.readFieldBegin()
9552 
      if ftype == TType.STOP:
9553 
        break
9554 
      if fid == 1:
9555 
        if ftype == TType.I64:
9556 
          self.warehouseId = iprot.readI64();
9557 
        else:
9558 
          iprot.skip(ftype)
9559 
      else:
9560 
        iprot.skip(ftype)
9561 
      iprot.readFieldEnd()
9562 
    iprot.readStructEnd()
9563 
 
9564 
  def write(self, oprot):
9565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9567 
      return
9568 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9569 
    if self.warehouseId is not None:
1220 chandransh 9570 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9571 
      oprot.writeI64(self.warehouseId)
9572 
      oprot.writeFieldEnd()
9573 
    oprot.writeFieldStop()
9574 
    oprot.writeStructEnd()
9575 
 
3431 rajveer 9576 
  def validate(self):
9577 
    return
9578 
 
9579 
 
1220 chandransh 9580 
  def __repr__(self):
9581 
    L = ['%s=%r' % (key, value)
9582 
      for key, value in self.__dict__.iteritems()]
9583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9584 
 
9585 
  def __eq__(self, other):
9586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9587 
 
9588 
  def __ne__(self, other):
9589 
    return not (self == other)
9590 
 
9591 
class batchOrders_result:
9592 
  """
9593 
  Attributes:
9594 
   - success
9595 
   - ex
9596 
  """
9597 
 
9598 
  thrift_spec = (
9599 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9601 
  )
9602 
 
9603 
  def __init__(self, success=None, ex=None,):
9604 
    self.success = success
9605 
    self.ex = ex
9606 
 
9607 
  def read(self, iprot):
9608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9610 
      return
9611 
    iprot.readStructBegin()
9612 
    while True:
9613 
      (fname, ftype, fid) = iprot.readFieldBegin()
9614 
      if ftype == TType.STOP:
9615 
        break
9616 
      if fid == 0:
9617 
        if ftype == TType.LIST:
9618 
          self.success = []
4133 chandransh 9619 
          (_etype136, _size133) = iprot.readListBegin()
9620 
          for _i137 in xrange(_size133):
9621 
            _elem138 = Order()
9622 
            _elem138.read(iprot)
9623 
            self.success.append(_elem138)
1220 chandransh 9624 
          iprot.readListEnd()
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      elif fid == 1:
9628 
        if ftype == TType.STRUCT:
9629 
          self.ex = TransactionServiceException()
9630 
          self.ex.read(iprot)
9631 
        else:
9632 
          iprot.skip(ftype)
9633 
      else:
9634 
        iprot.skip(ftype)
9635 
      iprot.readFieldEnd()
9636 
    iprot.readStructEnd()
9637 
 
9638 
  def write(self, oprot):
9639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9641 
      return
9642 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9643 
    if self.success is not None:
1220 chandransh 9644 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9645 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9646 
      for iter139 in self.success:
9647 
        iter139.write(oprot)
1220 chandransh 9648 
      oprot.writeListEnd()
9649 
      oprot.writeFieldEnd()
3431 rajveer 9650 
    if self.ex is not None:
1220 chandransh 9651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9652 
      self.ex.write(oprot)
9653 
      oprot.writeFieldEnd()
9654 
    oprot.writeFieldStop()
9655 
    oprot.writeStructEnd()
9656 
 
3431 rajveer 9657 
  def validate(self):
9658 
    return
9659 
 
9660 
 
1220 chandransh 9661 
  def __repr__(self):
9662 
    L = ['%s=%r' % (key, value)
9663 
      for key, value in self.__dict__.iteritems()]
9664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9665 
 
9666 
  def __eq__(self, other):
9667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9668 
 
9669 
  def __ne__(self, other):
9670 
    return not (self == other)
9671 
 
1208 chandransh 9672 
class markOrderAsOutOfStock_args:
9673 
  """
9674 
  Attributes:
9675 
   - orderId
9676 
  """
9677 
 
9678 
  thrift_spec = (
9679 
    None, # 0
9680 
    (1, TType.I64, 'orderId', None, None, ), # 1
9681 
  )
9682 
 
9683 
  def __init__(self, orderId=None,):
9684 
    self.orderId = orderId
9685 
 
9686 
  def read(self, iprot):
9687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9689 
      return
9690 
    iprot.readStructBegin()
9691 
    while True:
9692 
      (fname, ftype, fid) = iprot.readFieldBegin()
9693 
      if ftype == TType.STOP:
9694 
        break
9695 
      if fid == 1:
9696 
        if ftype == TType.I64:
9697 
          self.orderId = iprot.readI64();
9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      else:
9701 
        iprot.skip(ftype)
9702 
      iprot.readFieldEnd()
9703 
    iprot.readStructEnd()
9704 
 
9705 
  def write(self, oprot):
9706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9708 
      return
9709 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9710 
    if self.orderId is not None:
1208 chandransh 9711 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9712 
      oprot.writeI64(self.orderId)
9713 
      oprot.writeFieldEnd()
9714 
    oprot.writeFieldStop()
9715 
    oprot.writeStructEnd()
9716 
 
3431 rajveer 9717 
  def validate(self):
9718 
    return
9719 
 
9720 
 
1208 chandransh 9721 
  def __repr__(self):
9722 
    L = ['%s=%r' % (key, value)
9723 
      for key, value in self.__dict__.iteritems()]
9724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9725 
 
9726 
  def __eq__(self, other):
9727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9728 
 
9729 
  def __ne__(self, other):
9730 
    return not (self == other)
9731 
 
9732 
class markOrderAsOutOfStock_result:
9733 
  """
9734 
  Attributes:
9735 
   - success
9736 
   - ex
9737 
  """
9738 
 
9739 
  thrift_spec = (
9740 
    (0, TType.BOOL, 'success', None, None, ), # 0
9741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9742 
  )
9743 
 
9744 
  def __init__(self, success=None, ex=None,):
9745 
    self.success = success
9746 
    self.ex = ex
9747 
 
9748 
  def read(self, iprot):
9749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9751 
      return
9752 
    iprot.readStructBegin()
9753 
    while True:
9754 
      (fname, ftype, fid) = iprot.readFieldBegin()
9755 
      if ftype == TType.STOP:
9756 
        break
9757 
      if fid == 0:
9758 
        if ftype == TType.BOOL:
9759 
          self.success = iprot.readBool();
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      elif fid == 1:
9763 
        if ftype == TType.STRUCT:
9764 
          self.ex = TransactionServiceException()
9765 
          self.ex.read(iprot)
9766 
        else:
9767 
          iprot.skip(ftype)
9768 
      else:
9769 
        iprot.skip(ftype)
9770 
      iprot.readFieldEnd()
9771 
    iprot.readStructEnd()
9772 
 
9773 
  def write(self, oprot):
9774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9776 
      return
9777 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9778 
    if self.success is not None:
1208 chandransh 9779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9780 
      oprot.writeBool(self.success)
9781 
      oprot.writeFieldEnd()
3431 rajveer 9782 
    if self.ex is not None:
1208 chandransh 9783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9784 
      self.ex.write(oprot)
9785 
      oprot.writeFieldEnd()
9786 
    oprot.writeFieldStop()
9787 
    oprot.writeStructEnd()
9788 
 
3431 rajveer 9789 
  def validate(self):
9790 
    return
9791 
 
9792 
 
1208 chandransh 9793 
  def __repr__(self):
9794 
    L = ['%s=%r' % (key, value)
9795 
      for key, value in self.__dict__.iteritems()]
9796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9797 
 
9798 
  def __eq__(self, other):
9799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9800 
 
9801 
  def __ne__(self, other):
9802 
    return not (self == other)
9803 
 
3064 chandransh 9804 
class verifyOrder_args:
759 chandransh 9805 
  """
9806 
  Attributes:
3064 chandransh 9807 
   - orderId
759 chandransh 9808 
  """
9809 
 
9810 
  thrift_spec = (
9811 
    None, # 0
3064 chandransh 9812 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9813 
  )
9814 
 
3064 chandransh 9815 
  def __init__(self, orderId=None,):
9816 
    self.orderId = orderId
759 chandransh 9817 
 
9818 
  def read(self, iprot):
9819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9821 
      return
9822 
    iprot.readStructBegin()
9823 
    while True:
9824 
      (fname, ftype, fid) = iprot.readFieldBegin()
9825 
      if ftype == TType.STOP:
9826 
        break
9827 
      if fid == 1:
9828 
        if ftype == TType.I64:
3064 chandransh 9829 
          self.orderId = iprot.readI64();
759 chandransh 9830 
        else:
9831 
          iprot.skip(ftype)
9832 
      else:
9833 
        iprot.skip(ftype)
9834 
      iprot.readFieldEnd()
9835 
    iprot.readStructEnd()
9836 
 
9837 
  def write(self, oprot):
9838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9840 
      return
3064 chandransh 9841 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9842 
    if self.orderId is not None:
3064 chandransh 9843 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9844 
      oprot.writeI64(self.orderId)
759 chandransh 9845 
      oprot.writeFieldEnd()
9846 
    oprot.writeFieldStop()
9847 
    oprot.writeStructEnd()
9848 
 
3431 rajveer 9849 
  def validate(self):
9850 
    return
9851 
 
9852 
 
759 chandransh 9853 
  def __repr__(self):
9854 
    L = ['%s=%r' % (key, value)
9855 
      for key, value in self.__dict__.iteritems()]
9856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9857 
 
9858 
  def __eq__(self, other):
9859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9860 
 
9861 
  def __ne__(self, other):
9862 
    return not (self == other)
9863 
 
3064 chandransh 9864 
class verifyOrder_result:
759 chandransh 9865 
  """
9866 
  Attributes:
9867 
   - success
9868 
   - ex
9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    (0, TType.BOOL, 'success', None, None, ), # 0
9873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9874 
  )
9875 
 
9876 
  def __init__(self, success=None, ex=None,):
9877 
    self.success = success
9878 
    self.ex = ex
9879 
 
9880 
  def read(self, iprot):
9881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9883 
      return
9884 
    iprot.readStructBegin()
9885 
    while True:
9886 
      (fname, ftype, fid) = iprot.readFieldBegin()
9887 
      if ftype == TType.STOP:
9888 
        break
9889 
      if fid == 0:
9890 
        if ftype == TType.BOOL:
9891 
          self.success = iprot.readBool();
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      elif fid == 1:
9895 
        if ftype == TType.STRUCT:
9896 
          self.ex = TransactionServiceException()
9897 
          self.ex.read(iprot)
9898 
        else:
9899 
          iprot.skip(ftype)
9900 
      else:
9901 
        iprot.skip(ftype)
9902 
      iprot.readFieldEnd()
9903 
    iprot.readStructEnd()
9904 
 
9905 
  def write(self, oprot):
9906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9908 
      return
3064 chandransh 9909 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9910 
    if self.success is not None:
759 chandransh 9911 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9912 
      oprot.writeBool(self.success)
9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.ex is not None:
759 chandransh 9915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9916 
      self.ex.write(oprot)
9917 
      oprot.writeFieldEnd()
9918 
    oprot.writeFieldStop()
9919 
    oprot.writeStructEnd()
9920 
 
3431 rajveer 9921 
  def validate(self):
9922 
    return
9923 
 
9924 
 
759 chandransh 9925 
  def __repr__(self):
9926 
    L = ['%s=%r' % (key, value)
9927 
      for key, value in self.__dict__.iteritems()]
9928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9929 
 
9930 
  def __eq__(self, other):
9931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9932 
 
9933 
  def __ne__(self, other):
9934 
    return not (self == other)
9935 
 
3064 chandransh 9936 
class acceptOrder_args:
1113 chandransh 9937 
  """
9938 
  Attributes:
3064 chandransh 9939 
   - orderId
1113 chandransh 9940 
  """
9941 
 
9942 
  thrift_spec = (
9943 
    None, # 0
3064 chandransh 9944 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9945 
  )
9946 
 
3064 chandransh 9947 
  def __init__(self, orderId=None,):
9948 
    self.orderId = orderId
1113 chandransh 9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 1:
9960 
        if ftype == TType.I64:
3064 chandransh 9961 
          self.orderId = iprot.readI64();
1113 chandransh 9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      else:
9965 
        iprot.skip(ftype)
9966 
      iprot.readFieldEnd()
9967 
    iprot.readStructEnd()
9968 
 
9969 
  def write(self, oprot):
9970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9972 
      return
3064 chandransh 9973 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9974 
    if self.orderId is not None:
3064 chandransh 9975 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9976 
      oprot.writeI64(self.orderId)
1113 chandransh 9977 
      oprot.writeFieldEnd()
9978 
    oprot.writeFieldStop()
9979 
    oprot.writeStructEnd()
9980 
 
3431 rajveer 9981 
  def validate(self):
9982 
    return
9983 
 
9984 
 
1113 chandransh 9985 
  def __repr__(self):
9986 
    L = ['%s=%r' % (key, value)
9987 
      for key, value in self.__dict__.iteritems()]
9988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9989 
 
9990 
  def __eq__(self, other):
9991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9992 
 
9993 
  def __ne__(self, other):
9994 
    return not (self == other)
9995 
 
3064 chandransh 9996 
class acceptOrder_result:
1113 chandransh 9997 
  """
9998 
  Attributes:
9999 
   - success
10000 
   - ex
10001 
  """
10002 
 
10003 
  thrift_spec = (
3064 chandransh 10004 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10006 
  )
10007 
 
10008 
  def __init__(self, success=None, ex=None,):
10009 
    self.success = success
10010 
    self.ex = ex
10011 
 
10012 
  def read(self, iprot):
10013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10015 
      return
10016 
    iprot.readStructBegin()
10017 
    while True:
10018 
      (fname, ftype, fid) = iprot.readFieldBegin()
10019 
      if ftype == TType.STOP:
10020 
        break
10021 
      if fid == 0:
3064 chandransh 10022 
        if ftype == TType.BOOL:
10023 
          self.success = iprot.readBool();
1113 chandransh 10024 
        else:
10025 
          iprot.skip(ftype)
10026 
      elif fid == 1:
10027 
        if ftype == TType.STRUCT:
10028 
          self.ex = TransactionServiceException()
10029 
          self.ex.read(iprot)
10030 
        else:
10031 
          iprot.skip(ftype)
10032 
      else:
10033 
        iprot.skip(ftype)
10034 
      iprot.readFieldEnd()
10035 
    iprot.readStructEnd()
10036 
 
10037 
  def write(self, oprot):
10038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10040 
      return
3064 chandransh 10041 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10042 
    if self.success is not None:
3064 chandransh 10043 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10044 
      oprot.writeBool(self.success)
1113 chandransh 10045 
      oprot.writeFieldEnd()
3431 rajveer 10046 
    if self.ex is not None:
1113 chandransh 10047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10048 
      self.ex.write(oprot)
10049 
      oprot.writeFieldEnd()
10050 
    oprot.writeFieldStop()
10051 
    oprot.writeStructEnd()
10052 
 
3431 rajveer 10053 
  def validate(self):
10054 
    return
10055 
 
10056 
 
1113 chandransh 10057 
  def __repr__(self):
10058 
    L = ['%s=%r' % (key, value)
10059 
      for key, value in self.__dict__.iteritems()]
10060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10061 
 
10062 
  def __eq__(self, other):
10063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10064 
 
10065 
  def __ne__(self, other):
10066 
    return not (self == other)
10067 
 
3064 chandransh 10068 
class addBillingDetails_args:
1135 chandransh 10069 
  """
10070 
  Attributes:
3064 chandransh 10071 
   - orderId
10072 
   - invoice_number
4283 anupam.sin 10073 
   - imeiNumber
10074 
   - itemNumber
3064 chandransh 10075 
   - billed_by
4264 rajveer 10076 
   - jacketNumber
4283 anupam.sin 10077 
   - billingType
10078 
   - vendorId
1135 chandransh 10079 
  """
10080 
 
10081 
  thrift_spec = (
10082 
    None, # 0
3064 chandransh 10083 
    (1, TType.I64, 'orderId', None, None, ), # 1
10084 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 10085 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
10086 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10087 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10088 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10089 
    (7, TType.I64, 'billingType', None, None, ), # 7
10090 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10091 
  )
10092 
 
4283 anupam.sin 10093 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10094 
    self.orderId = orderId
10095 
    self.invoice_number = invoice_number
4283 anupam.sin 10096 
    self.imeiNumber = imeiNumber
10097 
    self.itemNumber = itemNumber
3064 chandransh 10098 
    self.billed_by = billed_by
4264 rajveer 10099 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10100 
    self.billingType = billingType
10101 
    self.vendorId = vendorId
1135 chandransh 10102 
 
10103 
  def read(self, iprot):
10104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10106 
      return
10107 
    iprot.readStructBegin()
10108 
    while True:
10109 
      (fname, ftype, fid) = iprot.readFieldBegin()
10110 
      if ftype == TType.STOP:
10111 
        break
10112 
      if fid == 1:
10113 
        if ftype == TType.I64:
3064 chandransh 10114 
          self.orderId = iprot.readI64();
1135 chandransh 10115 
        else:
10116 
          iprot.skip(ftype)
10117 
      elif fid == 2:
3064 chandransh 10118 
        if ftype == TType.STRING:
10119 
          self.invoice_number = iprot.readString();
1135 chandransh 10120 
        else:
10121 
          iprot.skip(ftype)
3064 chandransh 10122 
      elif fid == 3:
4264 rajveer 10123 
        if ftype == TType.I64:
3064 chandransh 10124 
          self.imeiNumber = iprot.readI64();
10125 
        else:
10126 
          iprot.skip(ftype)
10127 
      elif fid == 4:
10128 
        if ftype == TType.STRING:
10129 
          self.itemNumber = iprot.readString();
10130 
        else:
10131 
          iprot.skip(ftype)
10132 
      elif fid == 5:
10133 
        if ftype == TType.STRING:
4283 anupam.sin 10134 
          self.billed_by = iprot.readString();
3064 chandransh 10135 
        else:
10136 
          iprot.skip(ftype)
10137 
      elif fid == 6:
10138 
        if ftype == TType.I64:
4283 anupam.sin 10139 
          self.jacketNumber = iprot.readI64();
10140 
        else:
10141 
          iprot.skip(ftype)
10142 
      elif fid == 7:
10143 
        if ftype == TType.I64:
3064 chandransh 10144 
          self.billingType = iprot.readI64();
10145 
        else:
10146 
          iprot.skip(ftype)
4283 anupam.sin 10147 
      elif fid == 8:
10148 
        if ftype == TType.I64:
10149 
          self.vendorId = iprot.readI64();
10150 
        else:
10151 
          iprot.skip(ftype)
1246 chandransh 10152 
      else:
10153 
        iprot.skip(ftype)
10154 
      iprot.readFieldEnd()
10155 
    iprot.readStructEnd()
10156 
 
10157 
  def write(self, oprot):
10158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10160 
      return
4283 anupam.sin 10161 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10162 
    if self.orderId is not None:
3064 chandransh 10163 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10164 
      oprot.writeI64(self.orderId)
1246 chandransh 10165 
      oprot.writeFieldEnd()
4283 anupam.sin 10166 
    if self.invoice_number is not None:
10167 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10168 
      oprot.writeString(self.invoice_number)
1246 chandransh 10169 
      oprot.writeFieldEnd()
3431 rajveer 10170 
    if self.imeiNumber is not None:
3064 chandransh 10171 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
10172 
      oprot.writeI64(self.imeiNumber)
10173 
      oprot.writeFieldEnd()
3431 rajveer 10174 
    if self.itemNumber is not None:
3064 chandransh 10175 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10176 
      oprot.writeString(self.itemNumber)
10177 
      oprot.writeFieldEnd()
4283 anupam.sin 10178 
    if self.billed_by is not None:
10179 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10180 
      oprot.writeString(self.billed_by)
3064 chandransh 10181 
      oprot.writeFieldEnd()
4283 anupam.sin 10182 
    if self.jacketNumber is not None:
10183 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10184 
      oprot.writeI64(self.jacketNumber)
10185 
      oprot.writeFieldEnd()
3431 rajveer 10186 
    if self.billingType is not None:
4283 anupam.sin 10187 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10188 
      oprot.writeI64(self.billingType)
10189 
      oprot.writeFieldEnd()
4283 anupam.sin 10190 
    if self.vendorId is not None:
10191 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10192 
      oprot.writeI64(self.vendorId)
10193 
      oprot.writeFieldEnd()
1246 chandransh 10194 
    oprot.writeFieldStop()
10195 
    oprot.writeStructEnd()
10196 
 
3431 rajveer 10197 
  def validate(self):
10198 
    return
10199 
 
10200 
 
1246 chandransh 10201 
  def __repr__(self):
10202 
    L = ['%s=%r' % (key, value)
10203 
      for key, value in self.__dict__.iteritems()]
10204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10205 
 
10206 
  def __eq__(self, other):
10207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10208 
 
10209 
  def __ne__(self, other):
10210 
    return not (self == other)
10211 
 
4283 anupam.sin 10212 
class addBillingDetails_result:
1246 chandransh 10213 
  """
10214 
  Attributes:
3064 chandransh 10215 
   - success
1246 chandransh 10216 
   - ex
10217 
  """
10218 
 
10219 
  thrift_spec = (
3064 chandransh 10220 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10222 
  )
10223 
 
3064 chandransh 10224 
  def __init__(self, success=None, ex=None,):
10225 
    self.success = success
1246 chandransh 10226 
    self.ex = ex
10227 
 
10228 
  def read(self, iprot):
10229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10231 
      return
10232 
    iprot.readStructBegin()
10233 
    while True:
10234 
      (fname, ftype, fid) = iprot.readFieldBegin()
10235 
      if ftype == TType.STOP:
10236 
        break
3064 chandransh 10237 
      if fid == 0:
10238 
        if ftype == TType.BOOL:
10239 
          self.success = iprot.readBool();
10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      elif fid == 1:
1246 chandransh 10243 
        if ftype == TType.STRUCT:
10244 
          self.ex = TransactionServiceException()
10245 
          self.ex.read(iprot)
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      else:
10249 
        iprot.skip(ftype)
10250 
      iprot.readFieldEnd()
10251 
    iprot.readStructEnd()
10252 
 
10253 
  def write(self, oprot):
10254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10256 
      return
4283 anupam.sin 10257 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10258 
    if self.success is not None:
3064 chandransh 10259 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10260 
      oprot.writeBool(self.success)
10261 
      oprot.writeFieldEnd()
3431 rajveer 10262 
    if self.ex is not None:
1246 chandransh 10263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10264 
      self.ex.write(oprot)
10265 
      oprot.writeFieldEnd()
10266 
    oprot.writeFieldStop()
10267 
    oprot.writeStructEnd()
10268 
 
3431 rajveer 10269 
  def validate(self):
10270 
    return
10271 
 
10272 
 
1246 chandransh 10273 
  def __repr__(self):
10274 
    L = ['%s=%r' % (key, value)
10275 
      for key, value in self.__dict__.iteritems()]
10276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10277 
 
10278 
  def __eq__(self, other):
10279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10280 
 
10281 
  def __ne__(self, other):
10282 
    return not (self == other)
10283 
 
4579 rajveer 10284 
class addInvoiceNumber_args:
10285 
  """
10286 
  Attributes:
10287 
   - orderId
10288 
   - invoiceNumber
10289 
  """
10290 
 
10291 
  thrift_spec = (
10292 
    None, # 0
10293 
    (1, TType.I64, 'orderId', None, None, ), # 1
10294 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10295 
  )
10296 
 
10297 
  def __init__(self, orderId=None, invoiceNumber=None,):
10298 
    self.orderId = orderId
10299 
    self.invoiceNumber = invoiceNumber
10300 
 
10301 
  def read(self, iprot):
10302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10304 
      return
10305 
    iprot.readStructBegin()
10306 
    while True:
10307 
      (fname, ftype, fid) = iprot.readFieldBegin()
10308 
      if ftype == TType.STOP:
10309 
        break
10310 
      if fid == 1:
10311 
        if ftype == TType.I64:
10312 
          self.orderId = iprot.readI64();
10313 
        else:
10314 
          iprot.skip(ftype)
10315 
      elif fid == 2:
10316 
        if ftype == TType.STRING:
10317 
          self.invoiceNumber = iprot.readString();
10318 
        else:
10319 
          iprot.skip(ftype)
10320 
      else:
10321 
        iprot.skip(ftype)
10322 
      iprot.readFieldEnd()
10323 
    iprot.readStructEnd()
10324 
 
10325 
  def write(self, oprot):
10326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10328 
      return
10329 
    oprot.writeStructBegin('addInvoiceNumber_args')
10330 
    if self.orderId is not None:
10331 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10332 
      oprot.writeI64(self.orderId)
10333 
      oprot.writeFieldEnd()
10334 
    if self.invoiceNumber is not None:
10335 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10336 
      oprot.writeString(self.invoiceNumber)
10337 
      oprot.writeFieldEnd()
10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
10356 
class addInvoiceNumber_result:
10357 
  """
10358 
  Attributes:
10359 
   - ex
10360 
  """
10361 
 
10362 
  thrift_spec = (
10363 
    None, # 0
10364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10365 
  )
10366 
 
10367 
  def __init__(self, ex=None,):
10368 
    self.ex = ex
10369 
 
10370 
  def read(self, iprot):
10371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10373 
      return
10374 
    iprot.readStructBegin()
10375 
    while True:
10376 
      (fname, ftype, fid) = iprot.readFieldBegin()
10377 
      if ftype == TType.STOP:
10378 
        break
10379 
      if fid == 1:
10380 
        if ftype == TType.STRUCT:
10381 
          self.ex = TransactionServiceException()
10382 
          self.ex.read(iprot)
10383 
        else:
10384 
          iprot.skip(ftype)
10385 
      else:
10386 
        iprot.skip(ftype)
10387 
      iprot.readFieldEnd()
10388 
    iprot.readStructEnd()
10389 
 
10390 
  def write(self, oprot):
10391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10393 
      return
10394 
    oprot.writeStructBegin('addInvoiceNumber_result')
10395 
    if self.ex is not None:
10396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10397 
      self.ex.write(oprot)
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 
 
3064 chandransh 10417 
class markOrdersAsManifested_args:
1408 ankur.sing 10418 
  """
10419 
  Attributes:
3064 chandransh 10420 
   - warehouseId
1408 ankur.sing 10421 
   - providerId
3064 chandransh 10422 
   - cod
1408 ankur.sing 10423 
  """
10424 
 
10425 
  thrift_spec = (
10426 
    None, # 0
3064 chandransh 10427 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10428 
    (2, TType.I64, 'providerId', None, None, ), # 2
10429 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10430 
  )
10431 
 
3064 chandransh 10432 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10433 
    self.warehouseId = warehouseId
1408 ankur.sing 10434 
    self.providerId = providerId
3064 chandransh 10435 
    self.cod = cod
1408 ankur.sing 10436 
 
10437 
  def read(self, iprot):
10438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10440 
      return
10441 
    iprot.readStructBegin()
10442 
    while True:
10443 
      (fname, ftype, fid) = iprot.readFieldBegin()
10444 
      if ftype == TType.STOP:
10445 
        break
10446 
      if fid == 1:
10447 
        if ftype == TType.I64:
3064 chandransh 10448 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10449 
        else:
10450 
          iprot.skip(ftype)
10451 
      elif fid == 2:
10452 
        if ftype == TType.I64:
3064 chandransh 10453 
          self.providerId = iprot.readI64();
1408 ankur.sing 10454 
        else:
10455 
          iprot.skip(ftype)
3064 chandransh 10456 
      elif fid == 3:
10457 
        if ftype == TType.BOOL:
10458 
          self.cod = iprot.readBool();
10459 
        else:
10460 
          iprot.skip(ftype)
1408 ankur.sing 10461 
      else:
10462 
        iprot.skip(ftype)
10463 
      iprot.readFieldEnd()
10464 
    iprot.readStructEnd()
10465 
 
10466 
  def write(self, oprot):
10467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10469 
      return
3064 chandransh 10470 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10471 
    if self.warehouseId is not None:
3064 chandransh 10472 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10473 
      oprot.writeI64(self.warehouseId)
10474 
      oprot.writeFieldEnd()
3431 rajveer 10475 
    if self.providerId is not None:
3064 chandransh 10476 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10477 
      oprot.writeI64(self.providerId)
10478 
      oprot.writeFieldEnd()
3431 rajveer 10479 
    if self.cod is not None:
3064 chandransh 10480 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10481 
      oprot.writeBool(self.cod)
1408 ankur.sing 10482 
      oprot.writeFieldEnd()
10483 
    oprot.writeFieldStop()
10484 
    oprot.writeStructEnd()
10485 
 
3431 rajveer 10486 
  def validate(self):
10487 
    return
10488 
 
10489 
 
1408 ankur.sing 10490 
  def __repr__(self):
10491 
    L = ['%s=%r' % (key, value)
10492 
      for key, value in self.__dict__.iteritems()]
10493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10494 
 
10495 
  def __eq__(self, other):
10496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10497 
 
10498 
  def __ne__(self, other):
10499 
    return not (self == other)
10500 
 
3064 chandransh 10501 
class markOrdersAsManifested_result:
1408 ankur.sing 10502 
  """
10503 
  Attributes:
10504 
   - success
3064 chandransh 10505 
   - ex
1408 ankur.sing 10506 
  """
10507 
 
10508 
  thrift_spec = (
3064 chandransh 10509 
    (0, TType.BOOL, 'success', None, None, ), # 0
10510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10511 
  )
10512 
 
3064 chandransh 10513 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10514 
    self.success = success
3064 chandransh 10515 
    self.ex = ex
1408 ankur.sing 10516 
 
10517 
  def read(self, iprot):
10518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10520 
      return
10521 
    iprot.readStructBegin()
10522 
    while True:
10523 
      (fname, ftype, fid) = iprot.readFieldBegin()
10524 
      if ftype == TType.STOP:
10525 
        break
10526 
      if fid == 0:
3064 chandransh 10527 
        if ftype == TType.BOOL:
10528 
          self.success = iprot.readBool();
1408 ankur.sing 10529 
        else:
10530 
          iprot.skip(ftype)
3064 chandransh 10531 
      elif fid == 1:
10532 
        if ftype == TType.STRUCT:
10533 
          self.ex = TransactionServiceException()
10534 
          self.ex.read(iprot)
10535 
        else:
10536 
          iprot.skip(ftype)
1408 ankur.sing 10537 
      else:
10538 
        iprot.skip(ftype)
10539 
      iprot.readFieldEnd()
10540 
    iprot.readStructEnd()
10541 
 
10542 
  def write(self, oprot):
10543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10545 
      return
3064 chandransh 10546 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10547 
    if self.success is not None:
3064 chandransh 10548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10549 
      oprot.writeBool(self.success)
1408 ankur.sing 10550 
      oprot.writeFieldEnd()
3431 rajveer 10551 
    if self.ex is not None:
3064 chandransh 10552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10553 
      self.ex.write(oprot)
10554 
      oprot.writeFieldEnd()
1408 ankur.sing 10555 
    oprot.writeFieldStop()
10556 
    oprot.writeStructEnd()
10557 
 
3431 rajveer 10558 
  def validate(self):
10559 
    return
10560 
 
10561 
 
1408 ankur.sing 10562 
  def __repr__(self):
10563 
    L = ['%s=%r' % (key, value)
10564 
      for key, value in self.__dict__.iteritems()]
10565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10566 
 
10567 
  def __eq__(self, other):
10568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10569 
 
10570 
  def __ne__(self, other):
10571 
    return not (self == other)
10572 
 
4410 rajveer 10573 
class markOrdersAsShippedFromWarehouse_args:
10574 
  """
10575 
  Attributes:
10576 
   - warehouseId
10577 
   - providerId
10578 
   - cod
10579 
  """
10580 
 
10581 
  thrift_spec = (
10582 
    None, # 0
10583 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10584 
    (2, TType.I64, 'providerId', None, None, ), # 2
10585 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10586 
  )
10587 
 
10588 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10589 
    self.warehouseId = warehouseId
10590 
    self.providerId = providerId
10591 
    self.cod = cod
10592 
 
10593 
  def read(self, iprot):
10594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10596 
      return
10597 
    iprot.readStructBegin()
10598 
    while True:
10599 
      (fname, ftype, fid) = iprot.readFieldBegin()
10600 
      if ftype == TType.STOP:
10601 
        break
10602 
      if fid == 1:
10603 
        if ftype == TType.I64:
10604 
          self.warehouseId = iprot.readI64();
10605 
        else:
10606 
          iprot.skip(ftype)
10607 
      elif fid == 2:
10608 
        if ftype == TType.I64:
10609 
          self.providerId = iprot.readI64();
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      elif fid == 3:
10613 
        if ftype == TType.BOOL:
10614 
          self.cod = iprot.readBool();
10615 
        else:
10616 
          iprot.skip(ftype)
10617 
      else:
10618 
        iprot.skip(ftype)
10619 
      iprot.readFieldEnd()
10620 
    iprot.readStructEnd()
10621 
 
10622 
  def write(self, oprot):
10623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10625 
      return
10626 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10627 
    if self.warehouseId is not None:
10628 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10629 
      oprot.writeI64(self.warehouseId)
10630 
      oprot.writeFieldEnd()
10631 
    if self.providerId is not None:
10632 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10633 
      oprot.writeI64(self.providerId)
10634 
      oprot.writeFieldEnd()
10635 
    if self.cod is not None:
10636 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10637 
      oprot.writeBool(self.cod)
10638 
      oprot.writeFieldEnd()
10639 
    oprot.writeFieldStop()
10640 
    oprot.writeStructEnd()
10641 
 
10642 
  def validate(self):
10643 
    return
10644 
 
10645 
 
10646 
  def __repr__(self):
10647 
    L = ['%s=%r' % (key, value)
10648 
      for key, value in self.__dict__.iteritems()]
10649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10650 
 
10651 
  def __eq__(self, other):
10652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10653 
 
10654 
  def __ne__(self, other):
10655 
    return not (self == other)
10656 
 
10657 
class markOrdersAsShippedFromWarehouse_result:
10658 
  """
10659 
  Attributes:
10660 
   - success
10661 
   - ex
10662 
  """
10663 
 
10664 
  thrift_spec = (
10665 
    (0, TType.BOOL, 'success', None, None, ), # 0
10666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10667 
  )
10668 
 
10669 
  def __init__(self, success=None, ex=None,):
10670 
    self.success = success
10671 
    self.ex = ex
10672 
 
10673 
  def read(self, iprot):
10674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10676 
      return
10677 
    iprot.readStructBegin()
10678 
    while True:
10679 
      (fname, ftype, fid) = iprot.readFieldBegin()
10680 
      if ftype == TType.STOP:
10681 
        break
10682 
      if fid == 0:
10683 
        if ftype == TType.BOOL:
10684 
          self.success = iprot.readBool();
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      elif fid == 1:
10688 
        if ftype == TType.STRUCT:
10689 
          self.ex = TransactionServiceException()
10690 
          self.ex.read(iprot)
10691 
        else:
10692 
          iprot.skip(ftype)
10693 
      else:
10694 
        iprot.skip(ftype)
10695 
      iprot.readFieldEnd()
10696 
    iprot.readStructEnd()
10697 
 
10698 
  def write(self, oprot):
10699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10701 
      return
10702 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10703 
    if self.success is not None:
10704 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10705 
      oprot.writeBool(self.success)
10706 
      oprot.writeFieldEnd()
10707 
    if self.ex is not None:
10708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10709 
      self.ex.write(oprot)
10710 
      oprot.writeFieldEnd()
10711 
    oprot.writeFieldStop()
10712 
    oprot.writeStructEnd()
10713 
 
10714 
  def validate(self):
10715 
    return
10716 
 
10717 
 
10718 
  def __repr__(self):
10719 
    L = ['%s=%r' % (key, value)
10720 
      for key, value in self.__dict__.iteritems()]
10721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10722 
 
10723 
  def __eq__(self, other):
10724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10725 
 
10726 
  def __ne__(self, other):
10727 
    return not (self == other)
10728 
 
3064 chandransh 10729 
class markOrdersAsPickedUp_args:
304 ashish 10730 
  """
10731 
  Attributes:
3064 chandransh 10732 
   - providerId
10733 
   - pickupDetails
304 ashish 10734 
  """
94 ashish 10735 
 
304 ashish 10736 
  thrift_spec = (
10737 
    None, # 0
3064 chandransh 10738 
    (1, TType.I64, 'providerId', None, None, ), # 1
10739 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10740 
  )
10741 
 
3064 chandransh 10742 
  def __init__(self, providerId=None, pickupDetails=None,):
10743 
    self.providerId = providerId
10744 
    self.pickupDetails = pickupDetails
304 ashish 10745 
 
10746 
  def read(self, iprot):
10747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10749 
      return
10750 
    iprot.readStructBegin()
10751 
    while True:
10752 
      (fname, ftype, fid) = iprot.readFieldBegin()
10753 
      if ftype == TType.STOP:
10754 
        break
10755 
      if fid == 1:
10756 
        if ftype == TType.I64:
3064 chandransh 10757 
          self.providerId = iprot.readI64();
304 ashish 10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      elif fid == 2:
3064 chandransh 10761 
        if ftype == TType.MAP:
10762 
          self.pickupDetails = {}
4133 chandransh 10763 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10764 
          for _i144 in xrange(_size140):
10765 
            _key145 = iprot.readString();
10766 
            _val146 = iprot.readString();
10767 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10768 
          iprot.readMapEnd()
304 ashish 10769 
        else:
10770 
          iprot.skip(ftype)
10771 
      else:
10772 
        iprot.skip(ftype)
10773 
      iprot.readFieldEnd()
10774 
    iprot.readStructEnd()
10775 
 
10776 
  def write(self, oprot):
10777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10779 
      return
3064 chandransh 10780 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10781 
    if self.providerId is not None:
3064 chandransh 10782 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10783 
      oprot.writeI64(self.providerId)
304 ashish 10784 
      oprot.writeFieldEnd()
3431 rajveer 10785 
    if self.pickupDetails is not None:
3064 chandransh 10786 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10787 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10788 
      for kiter147,viter148 in self.pickupDetails.items():
10789 
        oprot.writeString(kiter147)
10790 
        oprot.writeString(viter148)
3064 chandransh 10791 
      oprot.writeMapEnd()
304 ashish 10792 
      oprot.writeFieldEnd()
10793 
    oprot.writeFieldStop()
10794 
    oprot.writeStructEnd()
10795 
 
3431 rajveer 10796 
  def validate(self):
10797 
    return
10798 
 
10799 
 
304 ashish 10800 
  def __repr__(self):
10801 
    L = ['%s=%r' % (key, value)
10802 
      for key, value in self.__dict__.iteritems()]
10803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10804 
 
10805 
  def __eq__(self, other):
10806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10807 
 
10808 
  def __ne__(self, other):
10809 
    return not (self == other)
10810 
 
3064 chandransh 10811 
class markOrdersAsPickedUp_result:
304 ashish 10812 
  """
10813 
  Attributes:
10814 
   - success
3064 chandransh 10815 
   - ex
304 ashish 10816 
  """
10817 
 
10818 
  thrift_spec = (
3064 chandransh 10819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10821 
  )
10822 
 
3064 chandransh 10823 
  def __init__(self, success=None, ex=None,):
304 ashish 10824 
    self.success = success
3064 chandransh 10825 
    self.ex = ex
304 ashish 10826 
 
10827 
  def read(self, iprot):
10828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10830 
      return
10831 
    iprot.readStructBegin()
10832 
    while True:
10833 
      (fname, ftype, fid) = iprot.readFieldBegin()
10834 
      if ftype == TType.STOP:
10835 
        break
10836 
      if fid == 0:
10837 
        if ftype == TType.LIST:
10838 
          self.success = []
4133 chandransh 10839 
          (_etype152, _size149) = iprot.readListBegin()
10840 
          for _i153 in xrange(_size149):
10841 
            _elem154 = Order()
10842 
            _elem154.read(iprot)
10843 
            self.success.append(_elem154)
304 ashish 10844 
          iprot.readListEnd()
10845 
        else:
10846 
          iprot.skip(ftype)
3064 chandransh 10847 
      elif fid == 1:
10848 
        if ftype == TType.STRUCT:
10849 
          self.ex = TransactionServiceException()
10850 
          self.ex.read(iprot)
10851 
        else:
10852 
          iprot.skip(ftype)
304 ashish 10853 
      else:
10854 
        iprot.skip(ftype)
10855 
      iprot.readFieldEnd()
10856 
    iprot.readStructEnd()
10857 
 
10858 
  def write(self, oprot):
10859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10861 
      return
3064 chandransh 10862 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10863 
    if self.success is not None:
304 ashish 10864 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10865 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10866 
      for iter155 in self.success:
10867 
        iter155.write(oprot)
304 ashish 10868 
      oprot.writeListEnd()
10869 
      oprot.writeFieldEnd()
3431 rajveer 10870 
    if self.ex is not None:
3064 chandransh 10871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10872 
      self.ex.write(oprot)
10873 
      oprot.writeFieldEnd()
304 ashish 10874 
    oprot.writeFieldStop()
10875 
    oprot.writeStructEnd()
10876 
 
3431 rajveer 10877 
  def validate(self):
10878 
    return
10879 
 
10880 
 
304 ashish 10881 
  def __repr__(self):
10882 
    L = ['%s=%r' % (key, value)
10883 
      for key, value in self.__dict__.iteritems()]
10884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10885 
 
10886 
  def __eq__(self, other):
10887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10888 
 
10889 
  def __ne__(self, other):
10890 
    return not (self == other)
10891 
 
3064 chandransh 10892 
class markOrdersAsDelivered_args:
304 ashish 10893 
  """
10894 
  Attributes:
3064 chandransh 10895 
   - providerId
10896 
   - deliveredOrders
304 ashish 10897 
  """
10898 
 
10899 
  thrift_spec = (
10900 
    None, # 0
3064 chandransh 10901 
    (1, TType.I64, 'providerId', None, None, ), # 1
10902 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10903 
  )
10904 
 
3064 chandransh 10905 
  def __init__(self, providerId=None, deliveredOrders=None,):
10906 
    self.providerId = providerId
10907 
    self.deliveredOrders = deliveredOrders
304 ashish 10908 
 
10909 
  def read(self, iprot):
10910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10912 
      return
10913 
    iprot.readStructBegin()
10914 
    while True:
10915 
      (fname, ftype, fid) = iprot.readFieldBegin()
10916 
      if ftype == TType.STOP:
10917 
        break
10918 
      if fid == 1:
10919 
        if ftype == TType.I64:
3064 chandransh 10920 
          self.providerId = iprot.readI64();
304 ashish 10921 
        else:
10922 
          iprot.skip(ftype)
10923 
      elif fid == 2:
3064 chandransh 10924 
        if ftype == TType.MAP:
10925 
          self.deliveredOrders = {}
4133 chandransh 10926 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10927 
          for _i160 in xrange(_size156):
10928 
            _key161 = iprot.readString();
10929 
            _val162 = iprot.readString();
10930 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10931 
          iprot.readMapEnd()
304 ashish 10932 
        else:
10933 
          iprot.skip(ftype)
10934 
      else:
10935 
        iprot.skip(ftype)
10936 
      iprot.readFieldEnd()
10937 
    iprot.readStructEnd()
10938 
 
10939 
  def write(self, oprot):
10940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10942 
      return
3064 chandransh 10943 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10944 
    if self.providerId is not None:
3064 chandransh 10945 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10946 
      oprot.writeI64(self.providerId)
304 ashish 10947 
      oprot.writeFieldEnd()
3431 rajveer 10948 
    if self.deliveredOrders is not None:
3064 chandransh 10949 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10950 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10951 
      for kiter163,viter164 in self.deliveredOrders.items():
10952 
        oprot.writeString(kiter163)
10953 
        oprot.writeString(viter164)
3064 chandransh 10954 
      oprot.writeMapEnd()
304 ashish 10955 
      oprot.writeFieldEnd()
10956 
    oprot.writeFieldStop()
10957 
    oprot.writeStructEnd()
10958 
 
3431 rajveer 10959 
  def validate(self):
10960 
    return
10961 
 
10962 
 
304 ashish 10963 
  def __repr__(self):
10964 
    L = ['%s=%r' % (key, value)
10965 
      for key, value in self.__dict__.iteritems()]
10966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10967 
 
10968 
  def __eq__(self, other):
10969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10970 
 
10971 
  def __ne__(self, other):
10972 
    return not (self == other)
10973 
 
3064 chandransh 10974 
class markOrdersAsDelivered_result:
10975 
  """
10976 
  Attributes:
10977 
   - ex
10978 
  """
304 ashish 10979 
 
10980 
  thrift_spec = (
3064 chandransh 10981 
    None, # 0
10982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10983 
  )
10984 
 
3064 chandransh 10985 
  def __init__(self, ex=None,):
10986 
    self.ex = ex
304 ashish 10987 
 
1596 ankur.sing 10988 
  def read(self, iprot):
10989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10991 
      return
10992 
    iprot.readStructBegin()
10993 
    while True:
10994 
      (fname, ftype, fid) = iprot.readFieldBegin()
10995 
      if ftype == TType.STOP:
10996 
        break
3064 chandransh 10997 
      if fid == 1:
10998 
        if ftype == TType.STRUCT:
10999 
          self.ex = TransactionServiceException()
11000 
          self.ex.read(iprot)
11001 
        else:
11002 
          iprot.skip(ftype)
1596 ankur.sing 11003 
      else:
11004 
        iprot.skip(ftype)
11005 
      iprot.readFieldEnd()
11006 
    iprot.readStructEnd()
11007 
 
11008 
  def write(self, oprot):
11009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11011 
      return
3064 chandransh 11012 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11013 
    if self.ex is not None:
3064 chandransh 11014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11015 
      self.ex.write(oprot)
11016 
      oprot.writeFieldEnd()
1596 ankur.sing 11017 
    oprot.writeFieldStop()
11018 
    oprot.writeStructEnd()
11019 
 
3431 rajveer 11020 
  def validate(self):
11021 
    return
11022 
 
11023 
 
1596 ankur.sing 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 markOrdersAsFailed_args:
1596 ankur.sing 11036 
  """
11037 
  Attributes:
3064 chandransh 11038 
   - providerId
11039 
   - returnedOrders
1596 ankur.sing 11040 
  """
11041 
 
11042 
  thrift_spec = (
3064 chandransh 11043 
    None, # 0
11044 
    (1, TType.I64, 'providerId', None, None, ), # 1
11045 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11046 
  )
11047 
 
3064 chandransh 11048 
  def __init__(self, providerId=None, returnedOrders=None,):
11049 
    self.providerId = providerId
11050 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11051 
 
11052 
  def read(self, iprot):
11053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11055 
      return
11056 
    iprot.readStructBegin()
11057 
    while True:
11058 
      (fname, ftype, fid) = iprot.readFieldBegin()
11059 
      if ftype == TType.STOP:
11060 
        break
3064 chandransh 11061 
      if fid == 1:
1596 ankur.sing 11062 
        if ftype == TType.I64:
3064 chandransh 11063 
          self.providerId = iprot.readI64();
1596 ankur.sing 11064 
        else:
11065 
          iprot.skip(ftype)
3064 chandransh 11066 
      elif fid == 2:
11067 
        if ftype == TType.MAP:
11068 
          self.returnedOrders = {}
4133 chandransh 11069 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11070 
          for _i169 in xrange(_size165):
11071 
            _key170 = iprot.readString();
11072 
            _val171 = iprot.readString();
11073 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11074 
          iprot.readMapEnd()
11075 
        else:
11076 
          iprot.skip(ftype)
1596 ankur.sing 11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
3064 chandransh 11086 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11087 
    if self.providerId is not None:
3064 chandransh 11088 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11089 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11090 
      oprot.writeFieldEnd()
3431 rajveer 11091 
    if self.returnedOrders is not None:
3064 chandransh 11092 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11093 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11094 
      for kiter172,viter173 in self.returnedOrders.items():
11095 
        oprot.writeString(kiter172)
11096 
        oprot.writeString(viter173)
3064 chandransh 11097 
      oprot.writeMapEnd()
11098 
      oprot.writeFieldEnd()
1596 ankur.sing 11099 
    oprot.writeFieldStop()
11100 
    oprot.writeStructEnd()
11101 
 
3431 rajveer 11102 
  def validate(self):
11103 
    return
11104 
 
11105 
 
1596 ankur.sing 11106 
  def __repr__(self):
11107 
    L = ['%s=%r' % (key, value)
11108 
      for key, value in self.__dict__.iteritems()]
11109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11110 
 
11111 
  def __eq__(self, other):
11112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11113 
 
11114 
  def __ne__(self, other):
11115 
    return not (self == other)
11116 
 
3064 chandransh 11117 
class markOrdersAsFailed_result:
11118 
  """
11119 
  Attributes:
11120 
   - ex
11121 
  """
1596 ankur.sing 11122 
 
1627 ankur.sing 11123 
  thrift_spec = (
3064 chandransh 11124 
    None, # 0
11125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11126 
  )
11127 
 
3064 chandransh 11128 
  def __init__(self, ex=None,):
11129 
    self.ex = ex
11130 
 
1627 ankur.sing 11131 
  def read(self, iprot):
11132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11134 
      return
11135 
    iprot.readStructBegin()
11136 
    while True:
11137 
      (fname, ftype, fid) = iprot.readFieldBegin()
11138 
      if ftype == TType.STOP:
11139 
        break
3064 chandransh 11140 
      if fid == 1:
11141 
        if ftype == TType.STRUCT:
11142 
          self.ex = TransactionServiceException()
11143 
          self.ex.read(iprot)
11144 
        else:
11145 
          iprot.skip(ftype)
1627 ankur.sing 11146 
      else:
11147 
        iprot.skip(ftype)
11148 
      iprot.readFieldEnd()
11149 
    iprot.readStructEnd()
11150 
 
11151 
  def write(self, oprot):
11152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11154 
      return
3064 chandransh 11155 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11156 
    if self.ex is not None:
3064 chandransh 11157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11158 
      self.ex.write(oprot)
11159 
      oprot.writeFieldEnd()
1627 ankur.sing 11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
1627 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 updateNonDeliveryReason_args:
1627 ankur.sing 11179 
  """
11180 
  Attributes:
3064 chandransh 11181 
   - providerId
11182 
   - undeliveredOrders
1627 ankur.sing 11183 
  """
11184 
 
11185 
  thrift_spec = (
3064 chandransh 11186 
    None, # 0
11187 
    (1, TType.I64, 'providerId', None, None, ), # 1
11188 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11189 
  )
11190 
 
3064 chandransh 11191 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11192 
    self.providerId = providerId
11193 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11194 
 
11195 
  def read(self, iprot):
11196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11198 
      return
11199 
    iprot.readStructBegin()
11200 
    while True:
11201 
      (fname, ftype, fid) = iprot.readFieldBegin()
11202 
      if ftype == TType.STOP:
11203 
        break
3064 chandransh 11204 
      if fid == 1:
1627 ankur.sing 11205 
        if ftype == TType.I64:
3064 chandransh 11206 
          self.providerId = iprot.readI64();
1627 ankur.sing 11207 
        else:
11208 
          iprot.skip(ftype)
3064 chandransh 11209 
      elif fid == 2:
11210 
        if ftype == TType.MAP:
11211 
          self.undeliveredOrders = {}
4133 chandransh 11212 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11213 
          for _i178 in xrange(_size174):
11214 
            _key179 = iprot.readString();
11215 
            _val180 = iprot.readString();
11216 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11217 
          iprot.readMapEnd()
11218 
        else:
11219 
          iprot.skip(ftype)
1627 ankur.sing 11220 
      else:
11221 
        iprot.skip(ftype)
11222 
      iprot.readFieldEnd()
11223 
    iprot.readStructEnd()
11224 
 
11225 
  def write(self, oprot):
11226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11228 
      return
3064 chandransh 11229 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11230 
    if self.providerId is not None:
3064 chandransh 11231 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11232 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11233 
      oprot.writeFieldEnd()
3431 rajveer 11234 
    if self.undeliveredOrders is not None:
3064 chandransh 11235 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11236 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11237 
      for kiter181,viter182 in self.undeliveredOrders.items():
11238 
        oprot.writeString(kiter181)
11239 
        oprot.writeString(viter182)
3064 chandransh 11240 
      oprot.writeMapEnd()
11241 
      oprot.writeFieldEnd()
1627 ankur.sing 11242 
    oprot.writeFieldStop()
11243 
    oprot.writeStructEnd()
11244 
 
3431 rajveer 11245 
  def validate(self):
11246 
    return
11247 
 
11248 
 
1627 ankur.sing 11249 
  def __repr__(self):
11250 
    L = ['%s=%r' % (key, value)
11251 
      for key, value in self.__dict__.iteritems()]
11252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11253 
 
11254 
  def __eq__(self, other):
11255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11256 
 
11257 
  def __ne__(self, other):
11258 
    return not (self == other)
11259 
 
3064 chandransh 11260 
class updateNonDeliveryReason_result:
1627 ankur.sing 11261 
  """
11262 
  Attributes:
4581 phani.kuma 11263 
   - success
3064 chandransh 11264 
   - ex
1627 ankur.sing 11265 
  """
11266 
 
11267 
  thrift_spec = (
4581 phani.kuma 11268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11270 
  )
11271 
 
4581 phani.kuma 11272 
  def __init__(self, success=None, ex=None,):
11273 
    self.success = success
3064 chandransh 11274 
    self.ex = ex
1627 ankur.sing 11275 
 
11276 
  def read(self, iprot):
11277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11279 
      return
11280 
    iprot.readStructBegin()
11281 
    while True:
11282 
      (fname, ftype, fid) = iprot.readFieldBegin()
11283 
      if ftype == TType.STOP:
11284 
        break
4581 phani.kuma 11285 
      if fid == 0:
11286 
        if ftype == TType.LIST:
11287 
          self.success = []
11288 
          (_etype186, _size183) = iprot.readListBegin()
11289 
          for _i187 in xrange(_size183):
11290 
            _elem188 = Order()
11291 
            _elem188.read(iprot)
11292 
            self.success.append(_elem188)
11293 
          iprot.readListEnd()
11294 
        else:
11295 
          iprot.skip(ftype)
11296 
      elif fid == 1:
3064 chandransh 11297 
        if ftype == TType.STRUCT:
11298 
          self.ex = TransactionServiceException()
11299 
          self.ex.read(iprot)
1627 ankur.sing 11300 
        else:
11301 
          iprot.skip(ftype)
11302 
      else:
11303 
        iprot.skip(ftype)
11304 
      iprot.readFieldEnd()
11305 
    iprot.readStructEnd()
11306 
 
11307 
  def write(self, oprot):
11308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11310 
      return
3064 chandransh 11311 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11312 
    if self.success is not None:
11313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11315 
      for iter189 in self.success:
11316 
        iter189.write(oprot)
11317 
      oprot.writeListEnd()
11318 
      oprot.writeFieldEnd()
3431 rajveer 11319 
    if self.ex is not None:
3064 chandransh 11320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11321 
      self.ex.write(oprot)
1627 ankur.sing 11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
3431 rajveer 11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
1627 ankur.sing 11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
3064 chandransh 11341 
class getUndeliveredOrders_args:
1886 ankur.sing 11342 
  """
11343 
  Attributes:
3064 chandransh 11344 
   - providerId
11345 
   - warehouseId
1886 ankur.sing 11346 
  """
1627 ankur.sing 11347 
 
1886 ankur.sing 11348 
  thrift_spec = (
11349 
    None, # 0
3064 chandransh 11350 
    (1, TType.I64, 'providerId', None, None, ), # 1
11351 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11352 
  )
11353 
 
3064 chandransh 11354 
  def __init__(self, providerId=None, warehouseId=None,):
11355 
    self.providerId = providerId
11356 
    self.warehouseId = warehouseId
1886 ankur.sing 11357 
 
11358 
  def read(self, iprot):
11359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11361 
      return
11362 
    iprot.readStructBegin()
11363 
    while True:
11364 
      (fname, ftype, fid) = iprot.readFieldBegin()
11365 
      if ftype == TType.STOP:
11366 
        break
11367 
      if fid == 1:
11368 
        if ftype == TType.I64:
3064 chandransh 11369 
          self.providerId = iprot.readI64();
1886 ankur.sing 11370 
        else:
11371 
          iprot.skip(ftype)
3064 chandransh 11372 
      elif fid == 2:
11373 
        if ftype == TType.I64:
11374 
          self.warehouseId = iprot.readI64();
11375 
        else:
11376 
          iprot.skip(ftype)
1886 ankur.sing 11377 
      else:
11378 
        iprot.skip(ftype)
11379 
      iprot.readFieldEnd()
11380 
    iprot.readStructEnd()
11381 
 
11382 
  def write(self, oprot):
11383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11385 
      return
3064 chandransh 11386 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11387 
    if self.providerId is not None:
3064 chandransh 11388 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11389 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11390 
      oprot.writeFieldEnd()
3431 rajveer 11391 
    if self.warehouseId is not None:
3064 chandransh 11392 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11393 
      oprot.writeI64(self.warehouseId)
11394 
      oprot.writeFieldEnd()
1886 ankur.sing 11395 
    oprot.writeFieldStop()
11396 
    oprot.writeStructEnd()
11397 
 
3431 rajveer 11398 
  def validate(self):
11399 
    return
11400 
 
11401 
 
1886 ankur.sing 11402 
  def __repr__(self):
11403 
    L = ['%s=%r' % (key, value)
11404 
      for key, value in self.__dict__.iteritems()]
11405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11406 
 
11407 
  def __eq__(self, other):
11408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11409 
 
11410 
  def __ne__(self, other):
11411 
    return not (self == other)
11412 
 
3064 chandransh 11413 
class getUndeliveredOrders_result:
1886 ankur.sing 11414 
  """
11415 
  Attributes:
11416 
   - success
11417 
  """
11418 
 
11419 
  thrift_spec = (
11420 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11421 
  )
11422 
 
11423 
  def __init__(self, success=None,):
11424 
    self.success = success
11425 
 
11426 
  def read(self, iprot):
11427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11429 
      return
11430 
    iprot.readStructBegin()
11431 
    while True:
11432 
      (fname, ftype, fid) = iprot.readFieldBegin()
11433 
      if ftype == TType.STOP:
11434 
        break
11435 
      if fid == 0:
11436 
        if ftype == TType.LIST:
11437 
          self.success = []
4581 phani.kuma 11438 
          (_etype193, _size190) = iprot.readListBegin()
11439 
          for _i194 in xrange(_size190):
11440 
            _elem195 = Order()
11441 
            _elem195.read(iprot)
11442 
            self.success.append(_elem195)
1886 ankur.sing 11443 
          iprot.readListEnd()
11444 
        else:
11445 
          iprot.skip(ftype)
11446 
      else:
11447 
        iprot.skip(ftype)
11448 
      iprot.readFieldEnd()
11449 
    iprot.readStructEnd()
11450 
 
11451 
  def write(self, oprot):
11452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11454 
      return
3064 chandransh 11455 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11456 
    if self.success is not None:
1886 ankur.sing 11457 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11458 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11459 
      for iter196 in self.success:
11460 
        iter196.write(oprot)
1886 ankur.sing 11461 
      oprot.writeListEnd()
11462 
      oprot.writeFieldEnd()
11463 
    oprot.writeFieldStop()
11464 
    oprot.writeStructEnd()
11465 
 
3431 rajveer 11466 
  def validate(self):
11467 
    return
11468 
 
11469 
 
1886 ankur.sing 11470 
  def __repr__(self):
11471 
    L = ['%s=%r' % (key, value)
11472 
      for key, value in self.__dict__.iteritems()]
11473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11474 
 
11475 
  def __eq__(self, other):
11476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11477 
 
11478 
  def __ne__(self, other):
11479 
    return not (self == other)
11480 
 
2536 chandransh 11481 
class toggleDOAFlag_args:
11482 
  """
11483 
  Attributes:
11484 
   - orderId
11485 
  """
1886 ankur.sing 11486 
 
2536 chandransh 11487 
  thrift_spec = (
11488 
    None, # 0
11489 
    (1, TType.I64, 'orderId', None, None, ), # 1
11490 
  )
11491 
 
11492 
  def __init__(self, orderId=None,):
11493 
    self.orderId = orderId
11494 
 
11495 
  def read(self, iprot):
11496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11498 
      return
11499 
    iprot.readStructBegin()
11500 
    while True:
11501 
      (fname, ftype, fid) = iprot.readFieldBegin()
11502 
      if ftype == TType.STOP:
11503 
        break
11504 
      if fid == 1:
11505 
        if ftype == TType.I64:
11506 
          self.orderId = iprot.readI64();
11507 
        else:
11508 
          iprot.skip(ftype)
11509 
      else:
11510 
        iprot.skip(ftype)
11511 
      iprot.readFieldEnd()
11512 
    iprot.readStructEnd()
11513 
 
11514 
  def write(self, oprot):
11515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11517 
      return
11518 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11519 
    if self.orderId is not None:
2536 chandransh 11520 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11521 
      oprot.writeI64(self.orderId)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
2536 chandransh 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
11541 
class toggleDOAFlag_result:
11542 
  """
11543 
  Attributes:
11544 
   - success
11545 
   - ex
11546 
  """
11547 
 
11548 
  thrift_spec = (
11549 
    (0, TType.BOOL, 'success', None, None, ), # 0
11550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, success=None, ex=None,):
11554 
    self.success = success
11555 
    self.ex = ex
11556 
 
11557 
  def read(self, iprot):
11558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11560 
      return
11561 
    iprot.readStructBegin()
11562 
    while True:
11563 
      (fname, ftype, fid) = iprot.readFieldBegin()
11564 
      if ftype == TType.STOP:
11565 
        break
11566 
      if fid == 0:
11567 
        if ftype == TType.BOOL:
11568 
          self.success = iprot.readBool();
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      elif fid == 1:
11572 
        if ftype == TType.STRUCT:
11573 
          self.ex = TransactionServiceException()
11574 
          self.ex.read(iprot)
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
11586 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11587 
    if self.success is not None:
2536 chandransh 11588 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11589 
      oprot.writeBool(self.success)
11590 
      oprot.writeFieldEnd()
3431 rajveer 11591 
    if self.ex is not None:
2536 chandransh 11592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11593 
      self.ex.write(oprot)
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
3431 rajveer 11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
2536 chandransh 11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
4454 rajveer 11613 
class markOrderDoaRequestReceived_args:
11614 
  """
11615 
  Attributes:
11616 
   - orderId
11617 
  """
11618 
 
11619 
  thrift_spec = (
11620 
    None, # 0
11621 
    (1, TType.I64, 'orderId', None, None, ), # 1
11622 
  )
11623 
 
11624 
  def __init__(self, orderId=None,):
11625 
    self.orderId = orderId
11626 
 
11627 
  def read(self, iprot):
11628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11630 
      return
11631 
    iprot.readStructBegin()
11632 
    while True:
11633 
      (fname, ftype, fid) = iprot.readFieldBegin()
11634 
      if ftype == TType.STOP:
11635 
        break
11636 
      if fid == 1:
11637 
        if ftype == TType.I64:
11638 
          self.orderId = iprot.readI64();
11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
11650 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11651 
    if self.orderId is not None:
11652 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11653 
      oprot.writeI64(self.orderId)
11654 
      oprot.writeFieldEnd()
11655 
    oprot.writeFieldStop()
11656 
    oprot.writeStructEnd()
11657 
 
11658 
  def validate(self):
11659 
    return
11660 
 
11661 
 
11662 
  def __repr__(self):
11663 
    L = ['%s=%r' % (key, value)
11664 
      for key, value in self.__dict__.iteritems()]
11665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11666 
 
11667 
  def __eq__(self, other):
11668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11669 
 
11670 
  def __ne__(self, other):
11671 
    return not (self == other)
11672 
 
11673 
class markOrderDoaRequestReceived_result:
11674 
  """
11675 
  Attributes:
11676 
   - success
11677 
   - ex
11678 
  """
11679 
 
11680 
  thrift_spec = (
11681 
    (0, TType.BOOL, 'success', None, None, ), # 0
11682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11683 
  )
11684 
 
11685 
  def __init__(self, success=None, ex=None,):
11686 
    self.success = success
11687 
    self.ex = ex
11688 
 
11689 
  def read(self, iprot):
11690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11692 
      return
11693 
    iprot.readStructBegin()
11694 
    while True:
11695 
      (fname, ftype, fid) = iprot.readFieldBegin()
11696 
      if ftype == TType.STOP:
11697 
        break
11698 
      if fid == 0:
11699 
        if ftype == TType.BOOL:
11700 
          self.success = iprot.readBool();
11701 
        else:
11702 
          iprot.skip(ftype)
11703 
      elif fid == 1:
11704 
        if ftype == TType.STRUCT:
11705 
          self.ex = TransactionServiceException()
11706 
          self.ex.read(iprot)
11707 
        else:
11708 
          iprot.skip(ftype)
11709 
      else:
11710 
        iprot.skip(ftype)
11711 
      iprot.readFieldEnd()
11712 
    iprot.readStructEnd()
11713 
 
11714 
  def write(self, oprot):
11715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11717 
      return
11718 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11719 
    if self.success is not None:
11720 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11721 
      oprot.writeBool(self.success)
11722 
      oprot.writeFieldEnd()
11723 
    if self.ex is not None:
11724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11725 
      self.ex.write(oprot)
11726 
      oprot.writeFieldEnd()
11727 
    oprot.writeFieldStop()
11728 
    oprot.writeStructEnd()
11729 
 
11730 
  def validate(self):
11731 
    return
11732 
 
11733 
 
11734 
  def __repr__(self):
11735 
    L = ['%s=%r' % (key, value)
11736 
      for key, value in self.__dict__.iteritems()]
11737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11738 
 
11739 
  def __eq__(self, other):
11740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11741 
 
11742 
  def __ne__(self, other):
11743 
    return not (self == other)
11744 
 
11745 
class markOrderDoaRequestAuthorized_args:
11746 
  """
11747 
  Attributes:
11748 
   - orderId
11749 
   - isAuthorized
11750 
  """
11751 
 
11752 
  thrift_spec = (
11753 
    None, # 0
11754 
    (1, TType.I64, 'orderId', None, None, ), # 1
11755 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11756 
  )
11757 
 
11758 
  def __init__(self, orderId=None, isAuthorized=None,):
11759 
    self.orderId = orderId
11760 
    self.isAuthorized = isAuthorized
11761 
 
11762 
  def read(self, iprot):
11763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11765 
      return
11766 
    iprot.readStructBegin()
11767 
    while True:
11768 
      (fname, ftype, fid) = iprot.readFieldBegin()
11769 
      if ftype == TType.STOP:
11770 
        break
11771 
      if fid == 1:
11772 
        if ftype == TType.I64:
11773 
          self.orderId = iprot.readI64();
11774 
        else:
11775 
          iprot.skip(ftype)
11776 
      elif fid == 2:
11777 
        if ftype == TType.BOOL:
11778 
          self.isAuthorized = iprot.readBool();
11779 
        else:
11780 
          iprot.skip(ftype)
11781 
      else:
11782 
        iprot.skip(ftype)
11783 
      iprot.readFieldEnd()
11784 
    iprot.readStructEnd()
11785 
 
11786 
  def write(self, oprot):
11787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11789 
      return
11790 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11791 
    if self.orderId is not None:
11792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11793 
      oprot.writeI64(self.orderId)
11794 
      oprot.writeFieldEnd()
11795 
    if self.isAuthorized is not None:
11796 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11797 
      oprot.writeBool(self.isAuthorized)
11798 
      oprot.writeFieldEnd()
11799 
    oprot.writeFieldStop()
11800 
    oprot.writeStructEnd()
11801 
 
11802 
  def validate(self):
11803 
    return
11804 
 
11805 
 
11806 
  def __repr__(self):
11807 
    L = ['%s=%r' % (key, value)
11808 
      for key, value in self.__dict__.iteritems()]
11809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11810 
 
11811 
  def __eq__(self, other):
11812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11813 
 
11814 
  def __ne__(self, other):
11815 
    return not (self == other)
11816 
 
11817 
class markOrderDoaRequestAuthorized_result:
11818 
  """
11819 
  Attributes:
11820 
   - success
11821 
   - ex
11822 
  """
11823 
 
11824 
  thrift_spec = (
11825 
    (0, TType.BOOL, 'success', None, None, ), # 0
11826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11827 
  )
11828 
 
11829 
  def __init__(self, success=None, ex=None,):
11830 
    self.success = success
11831 
    self.ex = ex
11832 
 
11833 
  def read(self, iprot):
11834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11836 
      return
11837 
    iprot.readStructBegin()
11838 
    while True:
11839 
      (fname, ftype, fid) = iprot.readFieldBegin()
11840 
      if ftype == TType.STOP:
11841 
        break
11842 
      if fid == 0:
11843 
        if ftype == TType.BOOL:
11844 
          self.success = iprot.readBool();
11845 
        else:
11846 
          iprot.skip(ftype)
11847 
      elif fid == 1:
11848 
        if ftype == TType.STRUCT:
11849 
          self.ex = TransactionServiceException()
11850 
          self.ex.read(iprot)
11851 
        else:
11852 
          iprot.skip(ftype)
11853 
      else:
11854 
        iprot.skip(ftype)
11855 
      iprot.readFieldEnd()
11856 
    iprot.readStructEnd()
11857 
 
11858 
  def write(self, oprot):
11859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11861 
      return
11862 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11863 
    if self.success is not None:
11864 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11865 
      oprot.writeBool(self.success)
11866 
      oprot.writeFieldEnd()
11867 
    if self.ex is not None:
11868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11869 
      self.ex.write(oprot)
11870 
      oprot.writeFieldEnd()
11871 
    oprot.writeFieldStop()
11872 
    oprot.writeStructEnd()
11873 
 
11874 
  def validate(self):
11875 
    return
11876 
 
11877 
 
11878 
  def __repr__(self):
11879 
    L = ['%s=%r' % (key, value)
11880 
      for key, value in self.__dict__.iteritems()]
11881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11882 
 
11883 
  def __eq__(self, other):
11884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11885 
 
11886 
  def __ne__(self, other):
11887 
    return not (self == other)
11888 
 
4488 rajveer 11889 
class markOrderReturnRequestReceived_args:
11890 
  """
11891 
  Attributes:
11892 
   - orderId
11893 
  """
11894 
 
11895 
  thrift_spec = (
11896 
    None, # 0
11897 
    (1, TType.I64, 'orderId', None, None, ), # 1
11898 
  )
11899 
 
11900 
  def __init__(self, orderId=None,):
11901 
    self.orderId = orderId
11902 
 
11903 
  def read(self, iprot):
11904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11906 
      return
11907 
    iprot.readStructBegin()
11908 
    while True:
11909 
      (fname, ftype, fid) = iprot.readFieldBegin()
11910 
      if ftype == TType.STOP:
11911 
        break
11912 
      if fid == 1:
11913 
        if ftype == TType.I64:
11914 
          self.orderId = iprot.readI64();
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      else:
11918 
        iprot.skip(ftype)
11919 
      iprot.readFieldEnd()
11920 
    iprot.readStructEnd()
11921 
 
11922 
  def write(self, oprot):
11923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11925 
      return
11926 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11927 
    if self.orderId is not None:
11928 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11929 
      oprot.writeI64(self.orderId)
11930 
      oprot.writeFieldEnd()
11931 
    oprot.writeFieldStop()
11932 
    oprot.writeStructEnd()
11933 
 
11934 
  def validate(self):
11935 
    return
11936 
 
11937 
 
11938 
  def __repr__(self):
11939 
    L = ['%s=%r' % (key, value)
11940 
      for key, value in self.__dict__.iteritems()]
11941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11942 
 
11943 
  def __eq__(self, other):
11944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11945 
 
11946 
  def __ne__(self, other):
11947 
    return not (self == other)
11948 
 
11949 
class markOrderReturnRequestReceived_result:
11950 
  """
11951 
  Attributes:
11952 
   - success
11953 
   - ex
11954 
  """
11955 
 
11956 
  thrift_spec = (
11957 
    (0, TType.BOOL, 'success', None, None, ), # 0
11958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11959 
  )
11960 
 
11961 
  def __init__(self, success=None, ex=None,):
11962 
    self.success = success
11963 
    self.ex = ex
11964 
 
11965 
  def read(self, iprot):
11966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11968 
      return
11969 
    iprot.readStructBegin()
11970 
    while True:
11971 
      (fname, ftype, fid) = iprot.readFieldBegin()
11972 
      if ftype == TType.STOP:
11973 
        break
11974 
      if fid == 0:
11975 
        if ftype == TType.BOOL:
11976 
          self.success = iprot.readBool();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      elif fid == 1:
11980 
        if ftype == TType.STRUCT:
11981 
          self.ex = TransactionServiceException()
11982 
          self.ex.read(iprot)
11983 
        else:
11984 
          iprot.skip(ftype)
11985 
      else:
11986 
        iprot.skip(ftype)
11987 
      iprot.readFieldEnd()
11988 
    iprot.readStructEnd()
11989 
 
11990 
  def write(self, oprot):
11991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11993 
      return
11994 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11995 
    if self.success is not None:
11996 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11997 
      oprot.writeBool(self.success)
11998 
      oprot.writeFieldEnd()
11999 
    if self.ex is not None:
12000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12001 
      self.ex.write(oprot)
12002 
      oprot.writeFieldEnd()
12003 
    oprot.writeFieldStop()
12004 
    oprot.writeStructEnd()
12005 
 
12006 
  def validate(self):
12007 
    return
12008 
 
12009 
 
12010 
  def __repr__(self):
12011 
    L = ['%s=%r' % (key, value)
12012 
      for key, value in self.__dict__.iteritems()]
12013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12014 
 
12015 
  def __eq__(self, other):
12016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12017 
 
12018 
  def __ne__(self, other):
12019 
    return not (self == other)
12020 
 
12021 
class markOrderReturnRequestAuthorized_args:
12022 
  """
12023 
  Attributes:
12024 
   - orderId
12025 
   - isAuthorized
12026 
  """
12027 
 
12028 
  thrift_spec = (
12029 
    None, # 0
12030 
    (1, TType.I64, 'orderId', None, None, ), # 1
12031 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12032 
  )
12033 
 
12034 
  def __init__(self, orderId=None, isAuthorized=None,):
12035 
    self.orderId = orderId
12036 
    self.isAuthorized = isAuthorized
12037 
 
12038 
  def read(self, iprot):
12039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12041 
      return
12042 
    iprot.readStructBegin()
12043 
    while True:
12044 
      (fname, ftype, fid) = iprot.readFieldBegin()
12045 
      if ftype == TType.STOP:
12046 
        break
12047 
      if fid == 1:
12048 
        if ftype == TType.I64:
12049 
          self.orderId = iprot.readI64();
12050 
        else:
12051 
          iprot.skip(ftype)
12052 
      elif fid == 2:
12053 
        if ftype == TType.BOOL:
12054 
          self.isAuthorized = iprot.readBool();
12055 
        else:
12056 
          iprot.skip(ftype)
12057 
      else:
12058 
        iprot.skip(ftype)
12059 
      iprot.readFieldEnd()
12060 
    iprot.readStructEnd()
12061 
 
12062 
  def write(self, oprot):
12063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12065 
      return
12066 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12067 
    if self.orderId is not None:
12068 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12069 
      oprot.writeI64(self.orderId)
12070 
      oprot.writeFieldEnd()
12071 
    if self.isAuthorized is not None:
12072 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12073 
      oprot.writeBool(self.isAuthorized)
12074 
      oprot.writeFieldEnd()
12075 
    oprot.writeFieldStop()
12076 
    oprot.writeStructEnd()
12077 
 
12078 
  def validate(self):
12079 
    return
12080 
 
12081 
 
12082 
  def __repr__(self):
12083 
    L = ['%s=%r' % (key, value)
12084 
      for key, value in self.__dict__.iteritems()]
12085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12086 
 
12087 
  def __eq__(self, other):
12088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12089 
 
12090 
  def __ne__(self, other):
12091 
    return not (self == other)
12092 
 
12093 
class markOrderReturnRequestAuthorized_result:
12094 
  """
12095 
  Attributes:
12096 
   - success
12097 
   - ex
12098 
  """
12099 
 
12100 
  thrift_spec = (
12101 
    (0, TType.BOOL, 'success', None, None, ), # 0
12102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12103 
  )
12104 
 
12105 
  def __init__(self, success=None, ex=None,):
12106 
    self.success = success
12107 
    self.ex = ex
12108 
 
12109 
  def read(self, iprot):
12110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12112 
      return
12113 
    iprot.readStructBegin()
12114 
    while True:
12115 
      (fname, ftype, fid) = iprot.readFieldBegin()
12116 
      if ftype == TType.STOP:
12117 
        break
12118 
      if fid == 0:
12119 
        if ftype == TType.BOOL:
12120 
          self.success = iprot.readBool();
12121 
        else:
12122 
          iprot.skip(ftype)
12123 
      elif fid == 1:
12124 
        if ftype == TType.STRUCT:
12125 
          self.ex = TransactionServiceException()
12126 
          self.ex.read(iprot)
12127 
        else:
12128 
          iprot.skip(ftype)
12129 
      else:
12130 
        iprot.skip(ftype)
12131 
      iprot.readFieldEnd()
12132 
    iprot.readStructEnd()
12133 
 
12134 
  def write(self, oprot):
12135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12137 
      return
12138 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12139 
    if self.success is not None:
12140 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12141 
      oprot.writeBool(self.success)
12142 
      oprot.writeFieldEnd()
12143 
    if self.ex is not None:
12144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12145 
      self.ex.write(oprot)
12146 
      oprot.writeFieldEnd()
12147 
    oprot.writeFieldStop()
12148 
    oprot.writeStructEnd()
12149 
 
12150 
  def validate(self):
12151 
    return
12152 
 
12153 
 
12154 
  def __repr__(self):
12155 
    L = ['%s=%r' % (key, value)
12156 
      for key, value in self.__dict__.iteritems()]
12157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12158 
 
12159 
  def __eq__(self, other):
12160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12161 
 
12162 
  def __ne__(self, other):
12163 
    return not (self == other)
12164 
 
2536 chandransh 12165 
class requestPickupNumber_args:
12166 
  """
12167 
  Attributes:
12168 
   - orderId
4579 rajveer 12169 
   - providerId
2536 chandransh 12170 
  """
12171 
 
12172 
  thrift_spec = (
12173 
    None, # 0
12174 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12175 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12176 
  )
12177 
 
4579 rajveer 12178 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12179 
    self.orderId = orderId
4579 rajveer 12180 
    self.providerId = providerId
2536 chandransh 12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 1:
12192 
        if ftype == TType.I64:
12193 
          self.orderId = iprot.readI64();
12194 
        else:
12195 
          iprot.skip(ftype)
4579 rajveer 12196 
      elif fid == 2:
12197 
        if ftype == TType.I64:
12198 
          self.providerId = iprot.readI64();
12199 
        else:
12200 
          iprot.skip(ftype)
2536 chandransh 12201 
      else:
12202 
        iprot.skip(ftype)
12203 
      iprot.readFieldEnd()
12204 
    iprot.readStructEnd()
12205 
 
12206 
  def write(self, oprot):
12207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12209 
      return
12210 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12211 
    if self.orderId is not None:
2536 chandransh 12212 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12213 
      oprot.writeI64(self.orderId)
12214 
      oprot.writeFieldEnd()
4579 rajveer 12215 
    if self.providerId is not None:
12216 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12217 
      oprot.writeI64(self.providerId)
12218 
      oprot.writeFieldEnd()
2536 chandransh 12219 
    oprot.writeFieldStop()
12220 
    oprot.writeStructEnd()
12221 
 
3431 rajveer 12222 
  def validate(self):
12223 
    return
12224 
 
12225 
 
2536 chandransh 12226 
  def __repr__(self):
12227 
    L = ['%s=%r' % (key, value)
12228 
      for key, value in self.__dict__.iteritems()]
12229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12230 
 
12231 
  def __eq__(self, other):
12232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12233 
 
12234 
  def __ne__(self, other):
12235 
    return not (self == other)
12236 
 
12237 
class requestPickupNumber_result:
12238 
  """
12239 
  Attributes:
12240 
   - success
12241 
   - ex
12242 
  """
12243 
 
12244 
  thrift_spec = (
12245 
    (0, TType.BOOL, 'success', None, None, ), # 0
12246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12247 
  )
12248 
 
12249 
  def __init__(self, success=None, ex=None,):
12250 
    self.success = success
12251 
    self.ex = ex
12252 
 
12253 
  def read(self, iprot):
12254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12256 
      return
12257 
    iprot.readStructBegin()
12258 
    while True:
12259 
      (fname, ftype, fid) = iprot.readFieldBegin()
12260 
      if ftype == TType.STOP:
12261 
        break
12262 
      if fid == 0:
12263 
        if ftype == TType.BOOL:
12264 
          self.success = iprot.readBool();
12265 
        else:
12266 
          iprot.skip(ftype)
12267 
      elif fid == 1:
12268 
        if ftype == TType.STRUCT:
12269 
          self.ex = TransactionServiceException()
12270 
          self.ex.read(iprot)
12271 
        else:
12272 
          iprot.skip(ftype)
12273 
      else:
12274 
        iprot.skip(ftype)
12275 
      iprot.readFieldEnd()
12276 
    iprot.readStructEnd()
12277 
 
12278 
  def write(self, oprot):
12279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12281 
      return
12282 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12283 
    if self.success is not None:
2536 chandransh 12284 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12285 
      oprot.writeBool(self.success)
12286 
      oprot.writeFieldEnd()
3431 rajveer 12287 
    if self.ex is not None:
2536 chandransh 12288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12289 
      self.ex.write(oprot)
12290 
      oprot.writeFieldEnd()
12291 
    oprot.writeFieldStop()
12292 
    oprot.writeStructEnd()
12293 
 
3431 rajveer 12294 
  def validate(self):
12295 
    return
12296 
 
12297 
 
2536 chandransh 12298 
  def __repr__(self):
12299 
    L = ['%s=%r' % (key, value)
12300 
      for key, value in self.__dict__.iteritems()]
12301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12302 
 
12303 
  def __eq__(self, other):
12304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12305 
 
12306 
  def __ne__(self, other):
12307 
    return not (self == other)
12308 
 
12309 
class authorizePickup_args:
12310 
  """
12311 
  Attributes:
12312 
   - orderId
12313 
   - pickupNumber
4602 rajveer 12314 
   - providerId
2536 chandransh 12315 
  """
12316 
 
12317 
  thrift_spec = (
12318 
    None, # 0
12319 
    (1, TType.I64, 'orderId', None, None, ), # 1
12320 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12321 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12322 
  )
12323 
 
4602 rajveer 12324 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12325 
    self.orderId = orderId
12326 
    self.pickupNumber = pickupNumber
4602 rajveer 12327 
    self.providerId = providerId
2536 chandransh 12328 
 
12329 
  def read(self, iprot):
12330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12332 
      return
12333 
    iprot.readStructBegin()
12334 
    while True:
12335 
      (fname, ftype, fid) = iprot.readFieldBegin()
12336 
      if ftype == TType.STOP:
12337 
        break
12338 
      if fid == 1:
12339 
        if ftype == TType.I64:
12340 
          self.orderId = iprot.readI64();
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      elif fid == 2:
12344 
        if ftype == TType.STRING:
12345 
          self.pickupNumber = iprot.readString();
12346 
        else:
12347 
          iprot.skip(ftype)
4602 rajveer 12348 
      elif fid == 3:
12349 
        if ftype == TType.I64:
12350 
          self.providerId = iprot.readI64();
12351 
        else:
12352 
          iprot.skip(ftype)
2536 chandransh 12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
12362 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12363 
    if self.orderId is not None:
2536 chandransh 12364 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12365 
      oprot.writeI64(self.orderId)
12366 
      oprot.writeFieldEnd()
3431 rajveer 12367 
    if self.pickupNumber is not None:
2536 chandransh 12368 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12369 
      oprot.writeString(self.pickupNumber)
12370 
      oprot.writeFieldEnd()
4602 rajveer 12371 
    if self.providerId is not None:
12372 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12373 
      oprot.writeI64(self.providerId)
12374 
      oprot.writeFieldEnd()
2536 chandransh 12375 
    oprot.writeFieldStop()
12376 
    oprot.writeStructEnd()
12377 
 
3431 rajveer 12378 
  def validate(self):
12379 
    return
12380 
 
12381 
 
2536 chandransh 12382 
  def __repr__(self):
12383 
    L = ['%s=%r' % (key, value)
12384 
      for key, value in self.__dict__.iteritems()]
12385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12386 
 
12387 
  def __eq__(self, other):
12388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12389 
 
12390 
  def __ne__(self, other):
12391 
    return not (self == other)
12392 
 
12393 
class authorizePickup_result:
12394 
  """
12395 
  Attributes:
12396 
   - success
12397 
   - ex
12398 
  """
12399 
 
12400 
  thrift_spec = (
12401 
    (0, TType.BOOL, 'success', None, None, ), # 0
12402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12403 
  )
12404 
 
12405 
  def __init__(self, success=None, ex=None,):
12406 
    self.success = success
12407 
    self.ex = ex
12408 
 
12409 
  def read(self, iprot):
12410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12412 
      return
12413 
    iprot.readStructBegin()
12414 
    while True:
12415 
      (fname, ftype, fid) = iprot.readFieldBegin()
12416 
      if ftype == TType.STOP:
12417 
        break
12418 
      if fid == 0:
12419 
        if ftype == TType.BOOL:
12420 
          self.success = iprot.readBool();
12421 
        else:
12422 
          iprot.skip(ftype)
12423 
      elif fid == 1:
12424 
        if ftype == TType.STRUCT:
12425 
          self.ex = TransactionServiceException()
12426 
          self.ex.read(iprot)
12427 
        else:
12428 
          iprot.skip(ftype)
12429 
      else:
12430 
        iprot.skip(ftype)
12431 
      iprot.readFieldEnd()
12432 
    iprot.readStructEnd()
12433 
 
12434 
  def write(self, oprot):
12435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12437 
      return
12438 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12439 
    if self.success is not None:
2536 chandransh 12440 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12441 
      oprot.writeBool(self.success)
12442 
      oprot.writeFieldEnd()
3431 rajveer 12443 
    if self.ex is not None:
2536 chandransh 12444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12445 
      self.ex.write(oprot)
12446 
      oprot.writeFieldEnd()
12447 
    oprot.writeFieldStop()
12448 
    oprot.writeStructEnd()
12449 
 
3431 rajveer 12450 
  def validate(self):
12451 
    return
12452 
 
12453 
 
2536 chandransh 12454 
  def __repr__(self):
12455 
    L = ['%s=%r' % (key, value)
12456 
      for key, value in self.__dict__.iteritems()]
12457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12458 
 
12459 
  def __eq__(self, other):
12460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12461 
 
12462 
  def __ne__(self, other):
12463 
    return not (self == other)
12464 
 
2764 chandransh 12465 
class markDoasAsPickedUp_args:
12466 
  """
12467 
  Attributes:
12468 
   - providerId
12469 
   - pickupDetails
12470 
  """
12471 
 
12472 
  thrift_spec = (
12473 
    None, # 0
12474 
    (1, TType.I64, 'providerId', None, None, ), # 1
12475 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12476 
  )
12477 
 
12478 
  def __init__(self, providerId=None, pickupDetails=None,):
12479 
    self.providerId = providerId
12480 
    self.pickupDetails = pickupDetails
12481 
 
12482 
  def read(self, iprot):
12483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12485 
      return
12486 
    iprot.readStructBegin()
12487 
    while True:
12488 
      (fname, ftype, fid) = iprot.readFieldBegin()
12489 
      if ftype == TType.STOP:
12490 
        break
12491 
      if fid == 1:
12492 
        if ftype == TType.I64:
12493 
          self.providerId = iprot.readI64();
12494 
        else:
12495 
          iprot.skip(ftype)
12496 
      elif fid == 2:
12497 
        if ftype == TType.MAP:
12498 
          self.pickupDetails = {}
4581 phani.kuma 12499 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12500 
          for _i201 in xrange(_size197):
12501 
            _key202 = iprot.readString();
12502 
            _val203 = iprot.readString();
12503 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12504 
          iprot.readMapEnd()
12505 
        else:
12506 
          iprot.skip(ftype)
12507 
      else:
12508 
        iprot.skip(ftype)
12509 
      iprot.readFieldEnd()
12510 
    iprot.readStructEnd()
12511 
 
12512 
  def write(self, oprot):
12513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12515 
      return
12516 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12517 
    if self.providerId is not None:
2764 chandransh 12518 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12519 
      oprot.writeI64(self.providerId)
12520 
      oprot.writeFieldEnd()
3431 rajveer 12521 
    if self.pickupDetails is not None:
2764 chandransh 12522 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12523 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12524 
      for kiter204,viter205 in self.pickupDetails.items():
12525 
        oprot.writeString(kiter204)
12526 
        oprot.writeString(viter205)
2764 chandransh 12527 
      oprot.writeMapEnd()
12528 
      oprot.writeFieldEnd()
12529 
    oprot.writeFieldStop()
12530 
    oprot.writeStructEnd()
12531 
 
3431 rajveer 12532 
  def validate(self):
12533 
    return
12534 
 
12535 
 
2764 chandransh 12536 
  def __repr__(self):
12537 
    L = ['%s=%r' % (key, value)
12538 
      for key, value in self.__dict__.iteritems()]
12539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12540 
 
12541 
  def __eq__(self, other):
12542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12543 
 
12544 
  def __ne__(self, other):
12545 
    return not (self == other)
12546 
 
12547 
class markDoasAsPickedUp_result:
12548 
  """
12549 
  Attributes:
12550 
   - success
12551 
  """
12552 
 
12553 
  thrift_spec = (
12554 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12555 
  )
12556 
 
12557 
  def __init__(self, success=None,):
12558 
    self.success = success
12559 
 
12560 
  def read(self, iprot):
12561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12563 
      return
12564 
    iprot.readStructBegin()
12565 
    while True:
12566 
      (fname, ftype, fid) = iprot.readFieldBegin()
12567 
      if ftype == TType.STOP:
12568 
        break
12569 
      if fid == 0:
12570 
        if ftype == TType.LIST:
12571 
          self.success = []
4581 phani.kuma 12572 
          (_etype209, _size206) = iprot.readListBegin()
12573 
          for _i210 in xrange(_size206):
12574 
            _elem211 = Order()
12575 
            _elem211.read(iprot)
12576 
            self.success.append(_elem211)
2764 chandransh 12577 
          iprot.readListEnd()
12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      else:
12581 
        iprot.skip(ftype)
12582 
      iprot.readFieldEnd()
12583 
    iprot.readStructEnd()
12584 
 
12585 
  def write(self, oprot):
12586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12588 
      return
12589 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12590 
    if self.success is not None:
2764 chandransh 12591 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12592 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12593 
      for iter212 in self.success:
12594 
        iter212.write(oprot)
2764 chandransh 12595 
      oprot.writeListEnd()
12596 
      oprot.writeFieldEnd()
12597 
    oprot.writeFieldStop()
12598 
    oprot.writeStructEnd()
12599 
 
3431 rajveer 12600 
  def validate(self):
12601 
    return
12602 
 
12603 
 
2764 chandransh 12604 
  def __repr__(self):
12605 
    L = ['%s=%r' % (key, value)
12606 
      for key, value in self.__dict__.iteritems()]
12607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12608 
 
12609 
  def __eq__(self, other):
12610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12611 
 
12612 
  def __ne__(self, other):
12613 
    return not (self == other)
12614 
 
2616 chandransh 12615 
class receiveReturn_args:
2591 chandransh 12616 
  """
12617 
  Attributes:
12618 
   - orderId
4479 rajveer 12619 
   - receiveCondition
2591 chandransh 12620 
  """
2536 chandransh 12621 
 
2591 chandransh 12622 
  thrift_spec = (
12623 
    None, # 0
12624 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12625 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12626 
  )
12627 
 
4479 rajveer 12628 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12629 
    self.orderId = orderId
4479 rajveer 12630 
    self.receiveCondition = receiveCondition
2591 chandransh 12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 1:
12642 
        if ftype == TType.I64:
12643 
          self.orderId = iprot.readI64();
12644 
        else:
12645 
          iprot.skip(ftype)
4479 rajveer 12646 
      elif fid == 2:
12647 
        if ftype == TType.I64:
12648 
          self.receiveCondition = iprot.readI64();
12649 
        else:
12650 
          iprot.skip(ftype)
2591 chandransh 12651 
      else:
12652 
        iprot.skip(ftype)
12653 
      iprot.readFieldEnd()
12654 
    iprot.readStructEnd()
12655 
 
12656 
  def write(self, oprot):
12657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12659 
      return
2616 chandransh 12660 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12661 
    if self.orderId is not None:
2591 chandransh 12662 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12663 
      oprot.writeI64(self.orderId)
12664 
      oprot.writeFieldEnd()
4479 rajveer 12665 
    if self.receiveCondition is not None:
12666 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12667 
      oprot.writeI64(self.receiveCondition)
12668 
      oprot.writeFieldEnd()
2591 chandransh 12669 
    oprot.writeFieldStop()
12670 
    oprot.writeStructEnd()
12671 
 
3431 rajveer 12672 
  def validate(self):
12673 
    return
12674 
 
12675 
 
2591 chandransh 12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12686 
 
2616 chandransh 12687 
class receiveReturn_result:
2591 chandransh 12688 
  """
12689 
  Attributes:
12690 
   - success
12691 
   - ex
12692 
  """
12693 
 
12694 
  thrift_spec = (
12695 
    (0, TType.BOOL, 'success', None, None, ), # 0
12696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12697 
  )
12698 
 
12699 
  def __init__(self, success=None, ex=None,):
12700 
    self.success = success
12701 
    self.ex = ex
12702 
 
12703 
  def read(self, iprot):
12704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12706 
      return
12707 
    iprot.readStructBegin()
12708 
    while True:
12709 
      (fname, ftype, fid) = iprot.readFieldBegin()
12710 
      if ftype == TType.STOP:
12711 
        break
12712 
      if fid == 0:
12713 
        if ftype == TType.BOOL:
12714 
          self.success = iprot.readBool();
12715 
        else:
12716 
          iprot.skip(ftype)
12717 
      elif fid == 1:
12718 
        if ftype == TType.STRUCT:
12719 
          self.ex = TransactionServiceException()
12720 
          self.ex.read(iprot)
12721 
        else:
12722 
          iprot.skip(ftype)
12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
2616 chandransh 12732 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12733 
    if self.success is not None:
2591 chandransh 12734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12735 
      oprot.writeBool(self.success)
12736 
      oprot.writeFieldEnd()
3431 rajveer 12737 
    if self.ex is not None:
2591 chandransh 12738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12739 
      self.ex.write(oprot)
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
3431 rajveer 12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
2591 chandransh 12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
12759 
class validateDoa_args:
12760 
  """
12761 
  Attributes:
12762 
   - orderId
12763 
   - isValid
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
12768 
    (1, TType.I64, 'orderId', None, None, ), # 1
12769 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12770 
  )
12771 
 
12772 
  def __init__(self, orderId=None, isValid=None,):
12773 
    self.orderId = orderId
12774 
    self.isValid = isValid
12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 1:
12786 
        if ftype == TType.I64:
12787 
          self.orderId = iprot.readI64();
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 2:
12791 
        if ftype == TType.BOOL:
12792 
          self.isValid = iprot.readBool();
12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
12804 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12805 
    if self.orderId is not None:
2591 chandransh 12806 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12807 
      oprot.writeI64(self.orderId)
12808 
      oprot.writeFieldEnd()
3431 rajveer 12809 
    if self.isValid is not None:
2591 chandransh 12810 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12811 
      oprot.writeBool(self.isValid)
12812 
      oprot.writeFieldEnd()
12813 
    oprot.writeFieldStop()
12814 
    oprot.writeStructEnd()
12815 
 
3431 rajveer 12816 
  def validate(self):
12817 
    return
12818 
 
12819 
 
2591 chandransh 12820 
  def __repr__(self):
12821 
    L = ['%s=%r' % (key, value)
12822 
      for key, value in self.__dict__.iteritems()]
12823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12824 
 
12825 
  def __eq__(self, other):
12826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12827 
 
12828 
  def __ne__(self, other):
12829 
    return not (self == other)
12830 
 
12831 
class validateDoa_result:
12832 
  """
12833 
  Attributes:
12834 
   - success
12835 
   - ex
12836 
  """
12837 
 
12838 
  thrift_spec = (
12839 
    (0, TType.BOOL, 'success', None, None, ), # 0
12840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12841 
  )
12842 
 
12843 
  def __init__(self, success=None, ex=None,):
12844 
    self.success = success
12845 
    self.ex = ex
12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      if fid == 0:
12857 
        if ftype == TType.BOOL:
12858 
          self.success = iprot.readBool();
12859 
        else:
12860 
          iprot.skip(ftype)
12861 
      elif fid == 1:
12862 
        if ftype == TType.STRUCT:
12863 
          self.ex = TransactionServiceException()
12864 
          self.ex.read(iprot)
12865 
        else:
12866 
          iprot.skip(ftype)
12867 
      else:
12868 
        iprot.skip(ftype)
12869 
      iprot.readFieldEnd()
12870 
    iprot.readStructEnd()
12871 
 
12872 
  def write(self, oprot):
12873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12875 
      return
12876 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12877 
    if self.success is not None:
2591 chandransh 12878 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12879 
      oprot.writeBool(self.success)
12880 
      oprot.writeFieldEnd()
3431 rajveer 12881 
    if self.ex is not None:
2591 chandransh 12882 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12883 
      self.ex.write(oprot)
12884 
      oprot.writeFieldEnd()
12885 
    oprot.writeFieldStop()
12886 
    oprot.writeStructEnd()
12887 
 
3431 rajveer 12888 
  def validate(self):
12889 
    return
12890 
 
12891 
 
2591 chandransh 12892 
  def __repr__(self):
12893 
    L = ['%s=%r' % (key, value)
12894 
      for key, value in self.__dict__.iteritems()]
12895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12896 
 
12897 
  def __eq__(self, other):
12898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12899 
 
12900 
  def __ne__(self, other):
12901 
    return not (self == other)
12902 
 
4495 rajveer 12903 
class validateReturnProduct_args:
12904 
  """
12905 
  Attributes:
12906 
   - orderId
12907 
   - isUsable
12908 
  """
12909 
 
12910 
  thrift_spec = (
12911 
    None, # 0
12912 
    (1, TType.I64, 'orderId', None, None, ), # 1
12913 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12914 
  )
12915 
 
12916 
  def __init__(self, orderId=None, isUsable=None,):
12917 
    self.orderId = orderId
12918 
    self.isUsable = isUsable
12919 
 
12920 
  def read(self, iprot):
12921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12923 
      return
12924 
    iprot.readStructBegin()
12925 
    while True:
12926 
      (fname, ftype, fid) = iprot.readFieldBegin()
12927 
      if ftype == TType.STOP:
12928 
        break
12929 
      if fid == 1:
12930 
        if ftype == TType.I64:
12931 
          self.orderId = iprot.readI64();
12932 
        else:
12933 
          iprot.skip(ftype)
12934 
      elif fid == 2:
12935 
        if ftype == TType.BOOL:
12936 
          self.isUsable = iprot.readBool();
12937 
        else:
12938 
          iprot.skip(ftype)
12939 
      else:
12940 
        iprot.skip(ftype)
12941 
      iprot.readFieldEnd()
12942 
    iprot.readStructEnd()
12943 
 
12944 
  def write(self, oprot):
12945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12947 
      return
12948 
    oprot.writeStructBegin('validateReturnProduct_args')
12949 
    if self.orderId is not None:
12950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12951 
      oprot.writeI64(self.orderId)
12952 
      oprot.writeFieldEnd()
12953 
    if self.isUsable is not None:
12954 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12955 
      oprot.writeBool(self.isUsable)
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
12975 
class validateReturnProduct_result:
12976 
  """
12977 
  Attributes:
12978 
   - success
12979 
   - ex
12980 
  """
12981 
 
12982 
  thrift_spec = (
12983 
    (0, TType.BOOL, 'success', None, None, ), # 0
12984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12985 
  )
12986 
 
12987 
  def __init__(self, success=None, ex=None,):
12988 
    self.success = success
12989 
    self.ex = ex
12990 
 
12991 
  def read(self, iprot):
12992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12994 
      return
12995 
    iprot.readStructBegin()
12996 
    while True:
12997 
      (fname, ftype, fid) = iprot.readFieldBegin()
12998 
      if ftype == TType.STOP:
12999 
        break
13000 
      if fid == 0:
13001 
        if ftype == TType.BOOL:
13002 
          self.success = iprot.readBool();
13003 
        else:
13004 
          iprot.skip(ftype)
13005 
      elif fid == 1:
13006 
        if ftype == TType.STRUCT:
13007 
          self.ex = TransactionServiceException()
13008 
          self.ex.read(iprot)
13009 
        else:
13010 
          iprot.skip(ftype)
13011 
      else:
13012 
        iprot.skip(ftype)
13013 
      iprot.readFieldEnd()
13014 
    iprot.readStructEnd()
13015 
 
13016 
  def write(self, oprot):
13017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13019 
      return
13020 
    oprot.writeStructBegin('validateReturnProduct_result')
13021 
    if self.success is not None:
13022 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13023 
      oprot.writeBool(self.success)
13024 
      oprot.writeFieldEnd()
13025 
    if self.ex is not None:
13026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13027 
      self.ex.write(oprot)
13028 
      oprot.writeFieldEnd()
13029 
    oprot.writeFieldStop()
13030 
    oprot.writeStructEnd()
13031 
 
13032 
  def validate(self):
13033 
    return
13034 
 
13035 
 
13036 
  def __repr__(self):
13037 
    L = ['%s=%r' % (key, value)
13038 
      for key, value in self.__dict__.iteritems()]
13039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13040 
 
13041 
  def __eq__(self, other):
13042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13043 
 
13044 
  def __ne__(self, other):
13045 
    return not (self == other)
13046 
 
2616 chandransh 13047 
class reshipOrder_args:
13048 
  """
13049 
  Attributes:
13050 
   - orderId
13051 
  """
2591 chandransh 13052 
 
2616 chandransh 13053 
  thrift_spec = (
13054 
    None, # 0
13055 
    (1, TType.I64, 'orderId', None, None, ), # 1
13056 
  )
13057 
 
13058 
  def __init__(self, orderId=None,):
13059 
    self.orderId = orderId
13060 
 
13061 
  def read(self, iprot):
13062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13064 
      return
13065 
    iprot.readStructBegin()
13066 
    while True:
13067 
      (fname, ftype, fid) = iprot.readFieldBegin()
13068 
      if ftype == TType.STOP:
13069 
        break
13070 
      if fid == 1:
13071 
        if ftype == TType.I64:
13072 
          self.orderId = iprot.readI64();
13073 
        else:
13074 
          iprot.skip(ftype)
13075 
      else:
13076 
        iprot.skip(ftype)
13077 
      iprot.readFieldEnd()
13078 
    iprot.readStructEnd()
13079 
 
13080 
  def write(self, oprot):
13081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13083 
      return
13084 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13085 
    if self.orderId is not None:
2616 chandransh 13086 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13087 
      oprot.writeI64(self.orderId)
13088 
      oprot.writeFieldEnd()
13089 
    oprot.writeFieldStop()
13090 
    oprot.writeStructEnd()
13091 
 
3431 rajveer 13092 
  def validate(self):
13093 
    return
13094 
 
13095 
 
2616 chandransh 13096 
  def __repr__(self):
13097 
    L = ['%s=%r' % (key, value)
13098 
      for key, value in self.__dict__.iteritems()]
13099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13100 
 
13101 
  def __eq__(self, other):
13102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13103 
 
13104 
  def __ne__(self, other):
13105 
    return not (self == other)
13106 
 
13107 
class reshipOrder_result:
13108 
  """
13109 
  Attributes:
13110 
   - success
13111 
   - ex
13112 
  """
13113 
 
13114 
  thrift_spec = (
13115 
    (0, TType.I64, 'success', None, None, ), # 0
13116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13117 
  )
13118 
 
13119 
  def __init__(self, success=None, ex=None,):
13120 
    self.success = success
13121 
    self.ex = ex
13122 
 
13123 
  def read(self, iprot):
13124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13126 
      return
13127 
    iprot.readStructBegin()
13128 
    while True:
13129 
      (fname, ftype, fid) = iprot.readFieldBegin()
13130 
      if ftype == TType.STOP:
13131 
        break
13132 
      if fid == 0:
13133 
        if ftype == TType.I64:
13134 
          self.success = iprot.readI64();
13135 
        else:
13136 
          iprot.skip(ftype)
13137 
      elif fid == 1:
13138 
        if ftype == TType.STRUCT:
13139 
          self.ex = TransactionServiceException()
13140 
          self.ex.read(iprot)
13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
13152 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13153 
    if self.success is not None:
2616 chandransh 13154 
      oprot.writeFieldBegin('success', TType.I64, 0)
13155 
      oprot.writeI64(self.success)
13156 
      oprot.writeFieldEnd()
3431 rajveer 13157 
    if self.ex is not None:
2616 chandransh 13158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13159 
      self.ex.write(oprot)
13160 
      oprot.writeFieldEnd()
13161 
    oprot.writeFieldStop()
13162 
    oprot.writeStructEnd()
13163 
 
3431 rajveer 13164 
  def validate(self):
13165 
    return
13166 
 
13167 
 
2616 chandransh 13168 
  def __repr__(self):
13169 
    L = ['%s=%r' % (key, value)
13170 
      for key, value in self.__dict__.iteritems()]
13171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13172 
 
13173 
  def __eq__(self, other):
13174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13175 
 
13176 
  def __ne__(self, other):
13177 
    return not (self == other)
13178 
 
13179 
class refundOrder_args:
13180 
  """
13181 
  Attributes:
13182 
   - orderId
3226 chandransh 13183 
   - refundedBy
13184 
   - reason
2616 chandransh 13185 
  """
13186 
 
13187 
  thrift_spec = (
13188 
    None, # 0
13189 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13190 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13191 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13192 
  )
13193 
 
3226 chandransh 13194 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13195 
    self.orderId = orderId
3226 chandransh 13196 
    self.refundedBy = refundedBy
13197 
    self.reason = reason
2616 chandransh 13198 
 
13199 
  def read(self, iprot):
13200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13202 
      return
13203 
    iprot.readStructBegin()
13204 
    while True:
13205 
      (fname, ftype, fid) = iprot.readFieldBegin()
13206 
      if ftype == TType.STOP:
13207 
        break
13208 
      if fid == 1:
13209 
        if ftype == TType.I64:
13210 
          self.orderId = iprot.readI64();
13211 
        else:
13212 
          iprot.skip(ftype)
3226 chandransh 13213 
      elif fid == 2:
13214 
        if ftype == TType.STRING:
13215 
          self.refundedBy = iprot.readString();
13216 
        else:
13217 
          iprot.skip(ftype)
13218 
      elif fid == 3:
13219 
        if ftype == TType.STRING:
13220 
          self.reason = iprot.readString();
13221 
        else:
13222 
          iprot.skip(ftype)
2616 chandransh 13223 
      else:
13224 
        iprot.skip(ftype)
13225 
      iprot.readFieldEnd()
13226 
    iprot.readStructEnd()
13227 
 
13228 
  def write(self, oprot):
13229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13231 
      return
13232 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13233 
    if self.orderId is not None:
2616 chandransh 13234 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13235 
      oprot.writeI64(self.orderId)
13236 
      oprot.writeFieldEnd()
3431 rajveer 13237 
    if self.refundedBy is not None:
3226 chandransh 13238 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13239 
      oprot.writeString(self.refundedBy)
13240 
      oprot.writeFieldEnd()
3431 rajveer 13241 
    if self.reason is not None:
3226 chandransh 13242 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13243 
      oprot.writeString(self.reason)
13244 
      oprot.writeFieldEnd()
2616 chandransh 13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
3431 rajveer 13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
2616 chandransh 13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
13263 
class refundOrder_result:
13264 
  """
13265 
  Attributes:
13266 
   - success
13267 
   - ex
13268 
  """
13269 
 
13270 
  thrift_spec = (
13271 
    (0, TType.BOOL, 'success', None, None, ), # 0
13272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13273 
  )
13274 
 
13275 
  def __init__(self, success=None, ex=None,):
13276 
    self.success = success
13277 
    self.ex = ex
13278 
 
13279 
  def read(self, iprot):
13280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13282 
      return
13283 
    iprot.readStructBegin()
13284 
    while True:
13285 
      (fname, ftype, fid) = iprot.readFieldBegin()
13286 
      if ftype == TType.STOP:
13287 
        break
13288 
      if fid == 0:
13289 
        if ftype == TType.BOOL:
13290 
          self.success = iprot.readBool();
13291 
        else:
13292 
          iprot.skip(ftype)
13293 
      elif fid == 1:
13294 
        if ftype == TType.STRUCT:
13295 
          self.ex = TransactionServiceException()
13296 
          self.ex.read(iprot)
13297 
        else:
13298 
          iprot.skip(ftype)
13299 
      else:
13300 
        iprot.skip(ftype)
13301 
      iprot.readFieldEnd()
13302 
    iprot.readStructEnd()
13303 
 
13304 
  def write(self, oprot):
13305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13307 
      return
13308 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13309 
    if self.success is not None:
2616 chandransh 13310 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13311 
      oprot.writeBool(self.success)
13312 
      oprot.writeFieldEnd()
3431 rajveer 13313 
    if self.ex is not None:
2616 chandransh 13314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13315 
      self.ex.write(oprot)
13316 
      oprot.writeFieldEnd()
13317 
    oprot.writeFieldStop()
13318 
    oprot.writeStructEnd()
13319 
 
3431 rajveer 13320 
  def validate(self):
13321 
    return
13322 
 
13323 
 
2616 chandransh 13324 
  def __repr__(self):
13325 
    L = ['%s=%r' % (key, value)
13326 
      for key, value in self.__dict__.iteritems()]
13327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13328 
 
13329 
  def __eq__(self, other):
13330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13331 
 
13332 
  def __ne__(self, other):
13333 
    return not (self == other)
13334 
 
2690 chandransh 13335 
class getReturnOrders_args:
13336 
  """
13337 
  Attributes:
13338 
   - warehouseId
13339 
   - fromDate
13340 
   - toDate
13341 
  """
2616 chandransh 13342 
 
2690 chandransh 13343 
  thrift_spec = (
13344 
    None, # 0
13345 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13346 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13347 
    (3, TType.I64, 'toDate', None, None, ), # 3
13348 
  )
13349 
 
13350 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13351 
    self.warehouseId = warehouseId
13352 
    self.fromDate = fromDate
13353 
    self.toDate = toDate
13354 
 
13355 
  def read(self, iprot):
13356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13358 
      return
13359 
    iprot.readStructBegin()
13360 
    while True:
13361 
      (fname, ftype, fid) = iprot.readFieldBegin()
13362 
      if ftype == TType.STOP:
13363 
        break
13364 
      if fid == 1:
13365 
        if ftype == TType.I64:
13366 
          self.warehouseId = iprot.readI64();
13367 
        else:
13368 
          iprot.skip(ftype)
13369 
      elif fid == 2:
13370 
        if ftype == TType.I64:
13371 
          self.fromDate = iprot.readI64();
13372 
        else:
13373 
          iprot.skip(ftype)
13374 
      elif fid == 3:
13375 
        if ftype == TType.I64:
13376 
          self.toDate = iprot.readI64();
13377 
        else:
13378 
          iprot.skip(ftype)
13379 
      else:
13380 
        iprot.skip(ftype)
13381 
      iprot.readFieldEnd()
13382 
    iprot.readStructEnd()
13383 
 
13384 
  def write(self, oprot):
13385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13387 
      return
13388 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13389 
    if self.warehouseId is not None:
2690 chandransh 13390 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13391 
      oprot.writeI64(self.warehouseId)
13392 
      oprot.writeFieldEnd()
3431 rajveer 13393 
    if self.fromDate is not None:
2690 chandransh 13394 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13395 
      oprot.writeI64(self.fromDate)
13396 
      oprot.writeFieldEnd()
3431 rajveer 13397 
    if self.toDate is not None:
2690 chandransh 13398 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13399 
      oprot.writeI64(self.toDate)
13400 
      oprot.writeFieldEnd()
13401 
    oprot.writeFieldStop()
13402 
    oprot.writeStructEnd()
13403 
 
3431 rajveer 13404 
  def validate(self):
13405 
    return
13406 
 
13407 
 
2690 chandransh 13408 
  def __repr__(self):
13409 
    L = ['%s=%r' % (key, value)
13410 
      for key, value in self.__dict__.iteritems()]
13411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13412 
 
13413 
  def __eq__(self, other):
13414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13415 
 
13416 
  def __ne__(self, other):
13417 
    return not (self == other)
13418 
 
13419 
class getReturnOrders_result:
13420 
  """
13421 
  Attributes:
13422 
   - success
13423 
  """
13424 
 
13425 
  thrift_spec = (
13426 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13427 
  )
13428 
 
13429 
  def __init__(self, success=None,):
13430 
    self.success = success
13431 
 
13432 
  def read(self, iprot):
13433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13435 
      return
13436 
    iprot.readStructBegin()
13437 
    while True:
13438 
      (fname, ftype, fid) = iprot.readFieldBegin()
13439 
      if ftype == TType.STOP:
13440 
        break
13441 
      if fid == 0:
13442 
        if ftype == TType.LIST:
13443 
          self.success = []
4581 phani.kuma 13444 
          (_etype216, _size213) = iprot.readListBegin()
13445 
          for _i217 in xrange(_size213):
13446 
            _elem218 = ReturnOrder()
13447 
            _elem218.read(iprot)
13448 
            self.success.append(_elem218)
2690 chandransh 13449 
          iprot.readListEnd()
13450 
        else:
13451 
          iprot.skip(ftype)
13452 
      else:
13453 
        iprot.skip(ftype)
13454 
      iprot.readFieldEnd()
13455 
    iprot.readStructEnd()
13456 
 
13457 
  def write(self, oprot):
13458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13460 
      return
13461 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13462 
    if self.success is not None:
2690 chandransh 13463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13465 
      for iter219 in self.success:
13466 
        iter219.write(oprot)
2690 chandransh 13467 
      oprot.writeListEnd()
13468 
      oprot.writeFieldEnd()
13469 
    oprot.writeFieldStop()
13470 
    oprot.writeStructEnd()
13471 
 
3431 rajveer 13472 
  def validate(self):
13473 
    return
13474 
 
13475 
 
2690 chandransh 13476 
  def __repr__(self):
13477 
    L = ['%s=%r' % (key, value)
13478 
      for key, value in self.__dict__.iteritems()]
13479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13480 
 
13481 
  def __eq__(self, other):
13482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13483 
 
13484 
  def __ne__(self, other):
13485 
    return not (self == other)
13486 
 
2700 chandransh 13487 
class getReturnOrder_args:
13488 
  """
13489 
  Attributes:
13490 
   - id
13491 
  """
13492 
 
13493 
  thrift_spec = (
13494 
    None, # 0
13495 
    (1, TType.I64, 'id', None, None, ), # 1
13496 
  )
13497 
 
13498 
  def __init__(self, id=None,):
13499 
    self.id = id
13500 
 
13501 
  def read(self, iprot):
13502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13504 
      return
13505 
    iprot.readStructBegin()
13506 
    while True:
13507 
      (fname, ftype, fid) = iprot.readFieldBegin()
13508 
      if ftype == TType.STOP:
13509 
        break
13510 
      if fid == 1:
13511 
        if ftype == TType.I64:
13512 
          self.id = iprot.readI64();
13513 
        else:
13514 
          iprot.skip(ftype)
13515 
      else:
13516 
        iprot.skip(ftype)
13517 
      iprot.readFieldEnd()
13518 
    iprot.readStructEnd()
13519 
 
13520 
  def write(self, oprot):
13521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13523 
      return
13524 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13525 
    if self.id is not None:
2700 chandransh 13526 
      oprot.writeFieldBegin('id', TType.I64, 1)
13527 
      oprot.writeI64(self.id)
13528 
      oprot.writeFieldEnd()
13529 
    oprot.writeFieldStop()
13530 
    oprot.writeStructEnd()
13531 
 
3431 rajveer 13532 
  def validate(self):
13533 
    return
13534 
 
13535 
 
2700 chandransh 13536 
  def __repr__(self):
13537 
    L = ['%s=%r' % (key, value)
13538 
      for key, value in self.__dict__.iteritems()]
13539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13540 
 
13541 
  def __eq__(self, other):
13542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13543 
 
13544 
  def __ne__(self, other):
13545 
    return not (self == other)
13546 
 
13547 
class getReturnOrder_result:
13548 
  """
13549 
  Attributes:
13550 
   - success
13551 
   - ex
13552 
  """
13553 
 
13554 
  thrift_spec = (
13555 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13556 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13557 
  )
13558 
 
13559 
  def __init__(self, success=None, ex=None,):
13560 
    self.success = success
13561 
    self.ex = ex
13562 
 
13563 
  def read(self, iprot):
13564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13566 
      return
13567 
    iprot.readStructBegin()
13568 
    while True:
13569 
      (fname, ftype, fid) = iprot.readFieldBegin()
13570 
      if ftype == TType.STOP:
13571 
        break
13572 
      if fid == 0:
13573 
        if ftype == TType.STRUCT:
13574 
          self.success = ReturnOrder()
13575 
          self.success.read(iprot)
13576 
        else:
13577 
          iprot.skip(ftype)
13578 
      elif fid == 1:
13579 
        if ftype == TType.STRUCT:
13580 
          self.ex = TransactionServiceException()
13581 
          self.ex.read(iprot)
13582 
        else:
13583 
          iprot.skip(ftype)
13584 
      else:
13585 
        iprot.skip(ftype)
13586 
      iprot.readFieldEnd()
13587 
    iprot.readStructEnd()
13588 
 
13589 
  def write(self, oprot):
13590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13592 
      return
13593 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13594 
    if self.success is not None:
2700 chandransh 13595 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13596 
      self.success.write(oprot)
13597 
      oprot.writeFieldEnd()
3431 rajveer 13598 
    if self.ex is not None:
2700 chandransh 13599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13600 
      self.ex.write(oprot)
13601 
      oprot.writeFieldEnd()
13602 
    oprot.writeFieldStop()
13603 
    oprot.writeStructEnd()
13604 
 
3431 rajveer 13605 
  def validate(self):
13606 
    return
13607 
 
13608 
 
2700 chandransh 13609 
  def __repr__(self):
13610 
    L = ['%s=%r' % (key, value)
13611 
      for key, value in self.__dict__.iteritems()]
13612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13613 
 
13614 
  def __eq__(self, other):
13615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13616 
 
13617 
  def __ne__(self, other):
13618 
    return not (self == other)
13619 
 
2690 chandransh 13620 
class processReturn_args:
13621 
  """
13622 
  Attributes:
13623 
   - returnOrderId
13624 
  """
13625 
 
13626 
  thrift_spec = (
13627 
    None, # 0
13628 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13629 
  )
13630 
 
13631 
  def __init__(self, returnOrderId=None,):
13632 
    self.returnOrderId = returnOrderId
13633 
 
13634 
  def read(self, iprot):
13635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13637 
      return
13638 
    iprot.readStructBegin()
13639 
    while True:
13640 
      (fname, ftype, fid) = iprot.readFieldBegin()
13641 
      if ftype == TType.STOP:
13642 
        break
13643 
      if fid == 1:
13644 
        if ftype == TType.I64:
13645 
          self.returnOrderId = iprot.readI64();
13646 
        else:
13647 
          iprot.skip(ftype)
13648 
      else:
13649 
        iprot.skip(ftype)
13650 
      iprot.readFieldEnd()
13651 
    iprot.readStructEnd()
13652 
 
13653 
  def write(self, oprot):
13654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13656 
      return
13657 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13658 
    if self.returnOrderId is not None:
2690 chandransh 13659 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13660 
      oprot.writeI64(self.returnOrderId)
13661 
      oprot.writeFieldEnd()
13662 
    oprot.writeFieldStop()
13663 
    oprot.writeStructEnd()
13664 
 
3431 rajveer 13665 
  def validate(self):
13666 
    return
13667 
 
13668 
 
2690 chandransh 13669 
  def __repr__(self):
13670 
    L = ['%s=%r' % (key, value)
13671 
      for key, value in self.__dict__.iteritems()]
13672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13673 
 
13674 
  def __eq__(self, other):
13675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13676 
 
13677 
  def __ne__(self, other):
13678 
    return not (self == other)
13679 
 
13680 
class processReturn_result:
13681 
  """
13682 
  Attributes:
13683 
   - ex
13684 
  """
13685 
 
13686 
  thrift_spec = (
13687 
    None, # 0
13688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13689 
  )
13690 
 
13691 
  def __init__(self, ex=None,):
13692 
    self.ex = ex
13693 
 
13694 
  def read(self, iprot):
13695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13697 
      return
13698 
    iprot.readStructBegin()
13699 
    while True:
13700 
      (fname, ftype, fid) = iprot.readFieldBegin()
13701 
      if ftype == TType.STOP:
13702 
        break
13703 
      if fid == 1:
13704 
        if ftype == TType.STRUCT:
13705 
          self.ex = TransactionServiceException()
13706 
          self.ex.read(iprot)
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_result')
3431 rajveer 13719 
    if self.ex is not None:
2690 chandransh 13720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13721 
      self.ex.write(oprot)
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 
 
2819 chandransh 13741 
class createPurchaseOrder_args:
13742 
  """
13743 
  Attributes:
13744 
   - warehouseId
13745 
  """
2690 chandransh 13746 
 
2819 chandransh 13747 
  thrift_spec = (
13748 
    None, # 0
13749 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13750 
  )
13751 
 
13752 
  def __init__(self, warehouseId=None,):
13753 
    self.warehouseId = warehouseId
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.I64:
13766 
          self.warehouseId = iprot.readI64();
13767 
        else:
13768 
          iprot.skip(ftype)
13769 
      else:
13770 
        iprot.skip(ftype)
13771 
      iprot.readFieldEnd()
13772 
    iprot.readStructEnd()
13773 
 
13774 
  def write(self, oprot):
13775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13777 
      return
13778 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13779 
    if self.warehouseId is not None:
2819 chandransh 13780 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13781 
      oprot.writeI64(self.warehouseId)
13782 
      oprot.writeFieldEnd()
13783 
    oprot.writeFieldStop()
13784 
    oprot.writeStructEnd()
13785 
 
3431 rajveer 13786 
  def validate(self):
13787 
    return
13788 
 
13789 
 
2819 chandransh 13790 
  def __repr__(self):
13791 
    L = ['%s=%r' % (key, value)
13792 
      for key, value in self.__dict__.iteritems()]
13793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13794 
 
13795 
  def __eq__(self, other):
13796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13797 
 
13798 
  def __ne__(self, other):
13799 
    return not (self == other)
13800 
 
13801 
class createPurchaseOrder_result:
13802 
  """
13803 
  Attributes:
13804 
   - success
13805 
   - ex
13806 
  """
13807 
 
13808 
  thrift_spec = (
4586 mandeep.dh 13809 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13810 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13811 
  )
13812 
 
13813 
  def __init__(self, success=None, ex=None,):
13814 
    self.success = success
13815 
    self.ex = ex
13816 
 
13817 
  def read(self, iprot):
13818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13820 
      return
13821 
    iprot.readStructBegin()
13822 
    while True:
13823 
      (fname, ftype, fid) = iprot.readFieldBegin()
13824 
      if ftype == TType.STOP:
13825 
        break
13826 
      if fid == 0:
4586 mandeep.dh 13827 
        if ftype == TType.LIST:
13828 
          self.success = []
13829 
          (_etype223, _size220) = iprot.readListBegin()
13830 
          for _i224 in xrange(_size220):
13831 
            _elem225 = iprot.readI64();
13832 
            self.success.append(_elem225)
13833 
          iprot.readListEnd()
2819 chandransh 13834 
        else:
13835 
          iprot.skip(ftype)
13836 
      elif fid == 1:
13837 
        if ftype == TType.STRUCT:
13838 
          self.ex = TransactionServiceException()
13839 
          self.ex.read(iprot)
13840 
        else:
13841 
          iprot.skip(ftype)
13842 
      else:
13843 
        iprot.skip(ftype)
13844 
      iprot.readFieldEnd()
13845 
    iprot.readStructEnd()
13846 
 
13847 
  def write(self, oprot):
13848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13850 
      return
13851 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13852 
    if self.success is not None:
4586 mandeep.dh 13853 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13854 
      oprot.writeListBegin(TType.I64, len(self.success))
13855 
      for iter226 in self.success:
13856 
        oprot.writeI64(iter226)
13857 
      oprot.writeListEnd()
2819 chandransh 13858 
      oprot.writeFieldEnd()
3431 rajveer 13859 
    if self.ex is not None:
2819 chandransh 13860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13861 
      self.ex.write(oprot)
13862 
      oprot.writeFieldEnd()
13863 
    oprot.writeFieldStop()
13864 
    oprot.writeStructEnd()
13865 
 
3431 rajveer 13866 
  def validate(self):
13867 
    return
13868 
 
13869 
 
2819 chandransh 13870 
  def __repr__(self):
13871 
    L = ['%s=%r' % (key, value)
13872 
      for key, value in self.__dict__.iteritems()]
13873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13874 
 
13875 
  def __eq__(self, other):
13876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13877 
 
13878 
  def __ne__(self, other):
13879 
    return not (self == other)
3451 chandransh 13880 
 
13881 
class updateWeight_args:
13882 
  """
13883 
  Attributes:
13884 
   - orderId
13885 
   - weight
13886 
  """
13887 
 
13888 
  thrift_spec = (
13889 
    None, # 0
13890 
    (1, TType.I64, 'orderId', None, None, ), # 1
13891 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13892 
  )
13893 
 
13894 
  def __init__(self, orderId=None, weight=None,):
13895 
    self.orderId = orderId
13896 
    self.weight = weight
13897 
 
13898 
  def read(self, iprot):
13899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13901 
      return
13902 
    iprot.readStructBegin()
13903 
    while True:
13904 
      (fname, ftype, fid) = iprot.readFieldBegin()
13905 
      if ftype == TType.STOP:
13906 
        break
13907 
      if fid == 1:
13908 
        if ftype == TType.I64:
13909 
          self.orderId = iprot.readI64();
13910 
        else:
13911 
          iprot.skip(ftype)
13912 
      elif fid == 2:
13913 
        if ftype == TType.DOUBLE:
13914 
          self.weight = iprot.readDouble();
13915 
        else:
13916 
          iprot.skip(ftype)
13917 
      else:
13918 
        iprot.skip(ftype)
13919 
      iprot.readFieldEnd()
13920 
    iprot.readStructEnd()
13921 
 
13922 
  def write(self, oprot):
13923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13925 
      return
13926 
    oprot.writeStructBegin('updateWeight_args')
13927 
    if self.orderId is not None:
13928 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13929 
      oprot.writeI64(self.orderId)
13930 
      oprot.writeFieldEnd()
13931 
    if self.weight is not None:
13932 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13933 
      oprot.writeDouble(self.weight)
13934 
      oprot.writeFieldEnd()
13935 
    oprot.writeFieldStop()
13936 
    oprot.writeStructEnd()
13937 
 
13938 
  def validate(self):
13939 
    return
13940 
 
13941 
 
13942 
  def __repr__(self):
13943 
    L = ['%s=%r' % (key, value)
13944 
      for key, value in self.__dict__.iteritems()]
13945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13946 
 
13947 
  def __eq__(self, other):
13948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13949 
 
13950 
  def __ne__(self, other):
13951 
    return not (self == other)
13952 
 
13953 
class updateWeight_result:
13954 
  """
13955 
  Attributes:
13956 
   - success
13957 
   - ex
13958 
  """
13959 
 
13960 
  thrift_spec = (
13961 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13963 
  )
13964 
 
13965 
  def __init__(self, success=None, ex=None,):
13966 
    self.success = success
13967 
    self.ex = ex
13968 
 
13969 
  def read(self, iprot):
13970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13972 
      return
13973 
    iprot.readStructBegin()
13974 
    while True:
13975 
      (fname, ftype, fid) = iprot.readFieldBegin()
13976 
      if ftype == TType.STOP:
13977 
        break
13978 
      if fid == 0:
13979 
        if ftype == TType.STRUCT:
13980 
          self.success = Order()
13981 
          self.success.read(iprot)
13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      elif fid == 1:
13985 
        if ftype == TType.STRUCT:
13986 
          self.ex = TransactionServiceException()
13987 
          self.ex.read(iprot)
13988 
        else:
13989 
          iprot.skip(ftype)
13990 
      else:
13991 
        iprot.skip(ftype)
13992 
      iprot.readFieldEnd()
13993 
    iprot.readStructEnd()
13994 
 
13995 
  def write(self, oprot):
13996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13998 
      return
13999 
    oprot.writeStructBegin('updateWeight_result')
14000 
    if self.success is not None:
14001 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14002 
      self.success.write(oprot)
14003 
      oprot.writeFieldEnd()
14004 
    if self.ex is not None:
14005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14006 
      self.ex.write(oprot)
14007 
      oprot.writeFieldEnd()
14008 
    oprot.writeFieldStop()
14009 
    oprot.writeStructEnd()
14010 
 
14011 
  def validate(self):
14012 
    return
14013 
 
14014 
 
14015 
  def __repr__(self):
14016 
    L = ['%s=%r' % (key, value)
14017 
      for key, value in self.__dict__.iteritems()]
14018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14019 
 
14020 
  def __eq__(self, other):
14021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14022 
 
14023 
  def __ne__(self, other):
14024 
    return not (self == other)
3469 chandransh 14025 
 
14026 
class changeItem_args:
14027 
  """
14028 
  Attributes:
14029 
   - orderId
14030 
   - itemId
14031 
  """
14032 
 
14033 
  thrift_spec = (
14034 
    None, # 0
14035 
    (1, TType.I64, 'orderId', None, None, ), # 1
14036 
    (2, TType.I64, 'itemId', None, None, ), # 2
14037 
  )
14038 
 
14039 
  def __init__(self, orderId=None, itemId=None,):
14040 
    self.orderId = orderId
14041 
    self.itemId = itemId
14042 
 
14043 
  def read(self, iprot):
14044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14046 
      return
14047 
    iprot.readStructBegin()
14048 
    while True:
14049 
      (fname, ftype, fid) = iprot.readFieldBegin()
14050 
      if ftype == TType.STOP:
14051 
        break
14052 
      if fid == 1:
14053 
        if ftype == TType.I64:
14054 
          self.orderId = iprot.readI64();
14055 
        else:
14056 
          iprot.skip(ftype)
14057 
      elif fid == 2:
14058 
        if ftype == TType.I64:
14059 
          self.itemId = iprot.readI64();
14060 
        else:
14061 
          iprot.skip(ftype)
14062 
      else:
14063 
        iprot.skip(ftype)
14064 
      iprot.readFieldEnd()
14065 
    iprot.readStructEnd()
14066 
 
14067 
  def write(self, oprot):
14068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14070 
      return
14071 
    oprot.writeStructBegin('changeItem_args')
14072 
    if self.orderId is not None:
14073 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14074 
      oprot.writeI64(self.orderId)
14075 
      oprot.writeFieldEnd()
14076 
    if self.itemId is not None:
14077 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14078 
      oprot.writeI64(self.itemId)
14079 
      oprot.writeFieldEnd()
14080 
    oprot.writeFieldStop()
14081 
    oprot.writeStructEnd()
14082 
 
14083 
  def validate(self):
14084 
    return
14085 
 
14086 
 
14087 
  def __repr__(self):
14088 
    L = ['%s=%r' % (key, value)
14089 
      for key, value in self.__dict__.iteritems()]
14090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14091 
 
14092 
  def __eq__(self, other):
14093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14094 
 
14095 
  def __ne__(self, other):
14096 
    return not (self == other)
14097 
 
14098 
class changeItem_result:
14099 
  """
14100 
  Attributes:
14101 
   - success
14102 
   - ex
14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14108 
  )
14109 
 
14110 
  def __init__(self, success=None, ex=None,):
14111 
    self.success = success
14112 
    self.ex = ex
14113 
 
14114 
  def read(self, iprot):
14115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14117 
      return
14118 
    iprot.readStructBegin()
14119 
    while True:
14120 
      (fname, ftype, fid) = iprot.readFieldBegin()
14121 
      if ftype == TType.STOP:
14122 
        break
14123 
      if fid == 0:
14124 
        if ftype == TType.STRUCT:
14125 
          self.success = Order()
14126 
          self.success.read(iprot)
14127 
        else:
14128 
          iprot.skip(ftype)
14129 
      elif fid == 1:
14130 
        if ftype == TType.STRUCT:
14131 
          self.ex = TransactionServiceException()
14132 
          self.ex.read(iprot)
14133 
        else:
14134 
          iprot.skip(ftype)
14135 
      else:
14136 
        iprot.skip(ftype)
14137 
      iprot.readFieldEnd()
14138 
    iprot.readStructEnd()
14139 
 
14140 
  def write(self, oprot):
14141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14143 
      return
14144 
    oprot.writeStructBegin('changeItem_result')
14145 
    if self.success is not None:
14146 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14147 
      self.success.write(oprot)
14148 
      oprot.writeFieldEnd()
14149 
    if self.ex is not None:
14150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14151 
      self.ex.write(oprot)
14152 
      oprot.writeFieldEnd()
14153 
    oprot.writeFieldStop()
14154 
    oprot.writeStructEnd()
14155 
 
14156 
  def validate(self):
14157 
    return
14158 
 
14159 
 
14160 
  def __repr__(self):
14161 
    L = ['%s=%r' % (key, value)
14162 
      for key, value in self.__dict__.iteritems()]
14163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14164 
 
14165 
  def __eq__(self, other):
14166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14167 
 
14168 
  def __ne__(self, other):
14169 
    return not (self == other)
14170 
 
14171 
class shiftToWarehouse_args:
14172 
  """
14173 
  Attributes:
14174 
   - orderId
14175 
   - warehouseId
14176 
  """
14177 
 
14178 
  thrift_spec = (
14179 
    None, # 0
14180 
    (1, TType.I64, 'orderId', None, None, ), # 1
14181 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14182 
  )
14183 
 
14184 
  def __init__(self, orderId=None, warehouseId=None,):
14185 
    self.orderId = orderId
14186 
    self.warehouseId = warehouseId
14187 
 
14188 
  def read(self, iprot):
14189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14191 
      return
14192 
    iprot.readStructBegin()
14193 
    while True:
14194 
      (fname, ftype, fid) = iprot.readFieldBegin()
14195 
      if ftype == TType.STOP:
14196 
        break
14197 
      if fid == 1:
14198 
        if ftype == TType.I64:
14199 
          self.orderId = iprot.readI64();
14200 
        else:
14201 
          iprot.skip(ftype)
14202 
      elif fid == 2:
14203 
        if ftype == TType.I64:
14204 
          self.warehouseId = iprot.readI64();
14205 
        else:
14206 
          iprot.skip(ftype)
14207 
      else:
14208 
        iprot.skip(ftype)
14209 
      iprot.readFieldEnd()
14210 
    iprot.readStructEnd()
14211 
 
14212 
  def write(self, oprot):
14213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14215 
      return
14216 
    oprot.writeStructBegin('shiftToWarehouse_args')
14217 
    if self.orderId is not None:
14218 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14219 
      oprot.writeI64(self.orderId)
14220 
      oprot.writeFieldEnd()
14221 
    if self.warehouseId is not None:
14222 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14223 
      oprot.writeI64(self.warehouseId)
14224 
      oprot.writeFieldEnd()
14225 
    oprot.writeFieldStop()
14226 
    oprot.writeStructEnd()
14227 
 
14228 
  def validate(self):
14229 
    return
14230 
 
14231 
 
14232 
  def __repr__(self):
14233 
    L = ['%s=%r' % (key, value)
14234 
      for key, value in self.__dict__.iteritems()]
14235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14236 
 
14237 
  def __eq__(self, other):
14238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14239 
 
14240 
  def __ne__(self, other):
14241 
    return not (self == other)
14242 
 
14243 
class shiftToWarehouse_result:
14244 
  """
14245 
  Attributes:
14246 
   - success
14247 
   - ex
14248 
  """
14249 
 
14250 
  thrift_spec = (
14251 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14252 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14253 
  )
14254 
 
14255 
  def __init__(self, success=None, ex=None,):
14256 
    self.success = success
14257 
    self.ex = ex
14258 
 
14259 
  def read(self, iprot):
14260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14262 
      return
14263 
    iprot.readStructBegin()
14264 
    while True:
14265 
      (fname, ftype, fid) = iprot.readFieldBegin()
14266 
      if ftype == TType.STOP:
14267 
        break
14268 
      if fid == 0:
14269 
        if ftype == TType.STRUCT:
14270 
          self.success = Order()
14271 
          self.success.read(iprot)
14272 
        else:
14273 
          iprot.skip(ftype)
14274 
      elif fid == 1:
14275 
        if ftype == TType.STRUCT:
14276 
          self.ex = TransactionServiceException()
14277 
          self.ex.read(iprot)
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      else:
14281 
        iprot.skip(ftype)
14282 
      iprot.readFieldEnd()
14283 
    iprot.readStructEnd()
14284 
 
14285 
  def write(self, oprot):
14286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14288 
      return
14289 
    oprot.writeStructBegin('shiftToWarehouse_result')
14290 
    if self.success is not None:
14291 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14292 
      self.success.write(oprot)
14293 
      oprot.writeFieldEnd()
14294 
    if self.ex is not None:
14295 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14296 
      self.ex.write(oprot)
14297 
      oprot.writeFieldEnd()
14298 
    oprot.writeFieldStop()
14299 
    oprot.writeStructEnd()
14300 
 
14301 
  def validate(self):
14302 
    return
14303 
 
14304 
 
14305 
  def __repr__(self):
14306 
    L = ['%s=%r' % (key, value)
14307 
      for key, value in self.__dict__.iteritems()]
14308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14309 
 
14310 
  def __eq__(self, other):
14311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14312 
 
14313 
  def __ne__(self, other):
14314 
    return not (self == other)
3553 chandransh 14315 
 
14316 
class addDelayReason_args:
14317 
  """
14318 
  Attributes:
14319 
   - orderId
14320 
   - delayReason
3986 chandransh 14321 
   - furtherDelay
3553 chandransh 14322 
  """
14323 
 
14324 
  thrift_spec = (
14325 
    None, # 0
14326 
    (1, TType.I64, 'orderId', None, None, ), # 1
14327 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14328 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 14329 
  )
14330 
 
3986 chandransh 14331 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 14332 
    self.orderId = orderId
14333 
    self.delayReason = delayReason
3986 chandransh 14334 
    self.furtherDelay = furtherDelay
3553 chandransh 14335 
 
14336 
  def read(self, iprot):
14337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14339 
      return
14340 
    iprot.readStructBegin()
14341 
    while True:
14342 
      (fname, ftype, fid) = iprot.readFieldBegin()
14343 
      if ftype == TType.STOP:
14344 
        break
14345 
      if fid == 1:
14346 
        if ftype == TType.I64:
14347 
          self.orderId = iprot.readI64();
14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      elif fid == 2:
14351 
        if ftype == TType.I32:
14352 
          self.delayReason = iprot.readI32();
14353 
        else:
14354 
          iprot.skip(ftype)
3986 chandransh 14355 
      elif fid == 3:
14356 
        if ftype == TType.I64:
14357 
          self.furtherDelay = iprot.readI64();
14358 
        else:
14359 
          iprot.skip(ftype)
3553 chandransh 14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
14369 
    oprot.writeStructBegin('addDelayReason_args')
14370 
    if self.orderId is not None:
14371 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14372 
      oprot.writeI64(self.orderId)
14373 
      oprot.writeFieldEnd()
14374 
    if self.delayReason is not None:
14375 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14376 
      oprot.writeI32(self.delayReason)
14377 
      oprot.writeFieldEnd()
3986 chandransh 14378 
    if self.furtherDelay is not None:
14379 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14380 
      oprot.writeI64(self.furtherDelay)
14381 
      oprot.writeFieldEnd()
3553 chandransh 14382 
    oprot.writeFieldStop()
14383 
    oprot.writeStructEnd()
14384 
 
14385 
  def validate(self):
14386 
    return
14387 
 
14388 
 
14389 
  def __repr__(self):
14390 
    L = ['%s=%r' % (key, value)
14391 
      for key, value in self.__dict__.iteritems()]
14392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14393 
 
14394 
  def __eq__(self, other):
14395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14396 
 
14397 
  def __ne__(self, other):
14398 
    return not (self == other)
14399 
 
14400 
class addDelayReason_result:
14401 
  """
14402 
  Attributes:
14403 
   - success
14404 
   - ex
14405 
  """
14406 
 
14407 
  thrift_spec = (
14408 
    (0, TType.BOOL, 'success', None, None, ), # 0
14409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14410 
  )
14411 
 
14412 
  def __init__(self, success=None, ex=None,):
14413 
    self.success = success
14414 
    self.ex = ex
14415 
 
14416 
  def read(self, iprot):
14417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14419 
      return
14420 
    iprot.readStructBegin()
14421 
    while True:
14422 
      (fname, ftype, fid) = iprot.readFieldBegin()
14423 
      if ftype == TType.STOP:
14424 
        break
14425 
      if fid == 0:
14426 
        if ftype == TType.BOOL:
14427 
          self.success = iprot.readBool();
14428 
        else:
14429 
          iprot.skip(ftype)
14430 
      elif fid == 1:
14431 
        if ftype == TType.STRUCT:
14432 
          self.ex = TransactionServiceException()
14433 
          self.ex.read(iprot)
14434 
        else:
14435 
          iprot.skip(ftype)
14436 
      else:
14437 
        iprot.skip(ftype)
14438 
      iprot.readFieldEnd()
14439 
    iprot.readStructEnd()
14440 
 
14441 
  def write(self, oprot):
14442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14444 
      return
14445 
    oprot.writeStructBegin('addDelayReason_result')
14446 
    if self.success is not None:
14447 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14448 
      oprot.writeBool(self.success)
14449 
      oprot.writeFieldEnd()
14450 
    if self.ex is not None:
14451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14452 
      self.ex.write(oprot)
14453 
      oprot.writeFieldEnd()
14454 
    oprot.writeFieldStop()
14455 
    oprot.writeStructEnd()
14456 
 
14457 
  def validate(self):
14458 
    return
14459 
 
14460 
 
14461 
  def __repr__(self):
14462 
    L = ['%s=%r' % (key, value)
14463 
      for key, value in self.__dict__.iteritems()]
14464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14465 
 
14466 
  def __eq__(self, other):
14467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14468 
 
14469 
  def __ne__(self, other):
14470 
    return not (self == other)
3956 chandransh 14471 
 
14472 
class reconcileCodCollection_args:
14473 
  """
14474 
  Attributes:
14475 
   - collectedAmountMap
14476 
   - xferBy
14477 
   - xferTxnId
14478 
   - xferDate
14479 
  """
14480 
 
14481 
  thrift_spec = (
14482 
    None, # 0
14483 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14484 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14485 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14486 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14487 
  )
14488 
 
14489 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14490 
    self.collectedAmountMap = collectedAmountMap
14491 
    self.xferBy = xferBy
14492 
    self.xferTxnId = xferTxnId
14493 
    self.xferDate = xferDate
14494 
 
14495 
  def read(self, iprot):
14496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14498 
      return
14499 
    iprot.readStructBegin()
14500 
    while True:
14501 
      (fname, ftype, fid) = iprot.readFieldBegin()
14502 
      if ftype == TType.STOP:
14503 
        break
14504 
      if fid == 1:
14505 
        if ftype == TType.MAP:
14506 
          self.collectedAmountMap = {}
4586 mandeep.dh 14507 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14508 
          for _i231 in xrange(_size227):
14509 
            _key232 = iprot.readString();
14510 
            _val233 = iprot.readDouble();
14511 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14512 
          iprot.readMapEnd()
14513 
        else:
14514 
          iprot.skip(ftype)
14515 
      elif fid == 2:
14516 
        if ftype == TType.STRING:
14517 
          self.xferBy = iprot.readString();
14518 
        else:
14519 
          iprot.skip(ftype)
14520 
      elif fid == 3:
14521 
        if ftype == TType.STRING:
14522 
          self.xferTxnId = iprot.readString();
14523 
        else:
14524 
          iprot.skip(ftype)
14525 
      elif fid == 4:
14526 
        if ftype == TType.I64:
14527 
          self.xferDate = iprot.readI64();
14528 
        else:
14529 
          iprot.skip(ftype)
14530 
      else:
14531 
        iprot.skip(ftype)
14532 
      iprot.readFieldEnd()
14533 
    iprot.readStructEnd()
14534 
 
14535 
  def write(self, oprot):
14536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14538 
      return
14539 
    oprot.writeStructBegin('reconcileCodCollection_args')
14540 
    if self.collectedAmountMap is not None:
14541 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14542 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14543 
      for kiter234,viter235 in self.collectedAmountMap.items():
14544 
        oprot.writeString(kiter234)
14545 
        oprot.writeDouble(viter235)
3956 chandransh 14546 
      oprot.writeMapEnd()
14547 
      oprot.writeFieldEnd()
14548 
    if self.xferBy is not None:
14549 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14550 
      oprot.writeString(self.xferBy)
14551 
      oprot.writeFieldEnd()
14552 
    if self.xferTxnId is not None:
14553 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14554 
      oprot.writeString(self.xferTxnId)
14555 
      oprot.writeFieldEnd()
14556 
    if self.xferDate is not None:
14557 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14558 
      oprot.writeI64(self.xferDate)
14559 
      oprot.writeFieldEnd()
14560 
    oprot.writeFieldStop()
14561 
    oprot.writeStructEnd()
14562 
 
14563 
  def validate(self):
14564 
    return
14565 
 
14566 
 
14567 
  def __repr__(self):
14568 
    L = ['%s=%r' % (key, value)
14569 
      for key, value in self.__dict__.iteritems()]
14570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14571 
 
14572 
  def __eq__(self, other):
14573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14574 
 
14575 
  def __ne__(self, other):
14576 
    return not (self == other)
14577 
 
14578 
class reconcileCodCollection_result:
14579 
  """
14580 
  Attributes:
14581 
   - success
14582 
   - ex
14583 
  """
14584 
 
14585 
  thrift_spec = (
14586 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14588 
  )
14589 
 
14590 
  def __init__(self, success=None, ex=None,):
14591 
    self.success = success
14592 
    self.ex = ex
14593 
 
14594 
  def read(self, iprot):
14595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14597 
      return
14598 
    iprot.readStructBegin()
14599 
    while True:
14600 
      (fname, ftype, fid) = iprot.readFieldBegin()
14601 
      if ftype == TType.STOP:
14602 
        break
14603 
      if fid == 0:
14604 
        if ftype == TType.MAP:
14605 
          self.success = {}
4586 mandeep.dh 14606 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14607 
          for _i240 in xrange(_size236):
14608 
            _key241 = iprot.readString();
14609 
            _val242 = iprot.readString();
14610 
            self.success[_key241] = _val242
3956 chandransh 14611 
          iprot.readMapEnd()
14612 
        else:
14613 
          iprot.skip(ftype)
14614 
      elif fid == 1:
14615 
        if ftype == TType.STRUCT:
14616 
          self.ex = TransactionServiceException()
14617 
          self.ex.read(iprot)
14618 
        else:
14619 
          iprot.skip(ftype)
14620 
      else:
14621 
        iprot.skip(ftype)
14622 
      iprot.readFieldEnd()
14623 
    iprot.readStructEnd()
14624 
 
14625 
  def write(self, oprot):
14626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14628 
      return
14629 
    oprot.writeStructBegin('reconcileCodCollection_result')
14630 
    if self.success is not None:
14631 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14632 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14633 
      for kiter243,viter244 in self.success.items():
14634 
        oprot.writeString(kiter243)
14635 
        oprot.writeString(viter244)
3956 chandransh 14636 
      oprot.writeMapEnd()
14637 
      oprot.writeFieldEnd()
14638 
    if self.ex is not None:
14639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14640 
      self.ex.write(oprot)
14641 
      oprot.writeFieldEnd()
14642 
    oprot.writeFieldStop()
14643 
    oprot.writeStructEnd()
14644 
 
14645 
  def validate(self):
14646 
    return
14647 
 
14648 
 
14649 
  def __repr__(self):
14650 
    L = ['%s=%r' % (key, value)
14651 
      for key, value in self.__dict__.iteritems()]
14652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14653 
 
14654 
  def __eq__(self, other):
14655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14656 
 
14657 
  def __ne__(self, other):
14658 
    return not (self == other)
4008 mandeep.dh 14659 
 
14660 
class getTransactionsRequiringExtraProcessing_args:
14661 
  """
14662 
  Attributes:
14663 
   - category
14664 
  """
14665 
 
14666 
  thrift_spec = (
14667 
    None, # 0
14668 
    (1, TType.I32, 'category', None, None, ), # 1
14669 
  )
14670 
 
14671 
  def __init__(self, category=None,):
14672 
    self.category = category
14673 
 
14674 
  def read(self, iprot):
14675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14677 
      return
14678 
    iprot.readStructBegin()
14679 
    while True:
14680 
      (fname, ftype, fid) = iprot.readFieldBegin()
14681 
      if ftype == TType.STOP:
14682 
        break
14683 
      if fid == 1:
14684 
        if ftype == TType.I32:
14685 
          self.category = iprot.readI32();
14686 
        else:
14687 
          iprot.skip(ftype)
14688 
      else:
14689 
        iprot.skip(ftype)
14690 
      iprot.readFieldEnd()
14691 
    iprot.readStructEnd()
14692 
 
14693 
  def write(self, oprot):
14694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14696 
      return
14697 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14698 
    if self.category is not None:
14699 
      oprot.writeFieldBegin('category', TType.I32, 1)
14700 
      oprot.writeI32(self.category)
14701 
      oprot.writeFieldEnd()
14702 
    oprot.writeFieldStop()
14703 
    oprot.writeStructEnd()
14704 
 
14705 
  def validate(self):
14706 
    return
14707 
 
14708 
 
14709 
  def __repr__(self):
14710 
    L = ['%s=%r' % (key, value)
14711 
      for key, value in self.__dict__.iteritems()]
14712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14713 
 
14714 
  def __eq__(self, other):
14715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14716 
 
14717 
  def __ne__(self, other):
14718 
    return not (self == other)
14719 
 
14720 
class getTransactionsRequiringExtraProcessing_result:
14721 
  """
14722 
  Attributes:
14723 
   - success
14724 
  """
14725 
 
14726 
  thrift_spec = (
14727 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14728 
  )
14729 
 
14730 
  def __init__(self, success=None,):
14731 
    self.success = success
14732 
 
14733 
  def read(self, iprot):
14734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14736 
      return
14737 
    iprot.readStructBegin()
14738 
    while True:
14739 
      (fname, ftype, fid) = iprot.readFieldBegin()
14740 
      if ftype == TType.STOP:
14741 
        break
14742 
      if fid == 0:
14743 
        if ftype == TType.LIST:
14744 
          self.success = []
4586 mandeep.dh 14745 
          (_etype248, _size245) = iprot.readListBegin()
14746 
          for _i249 in xrange(_size245):
14747 
            _elem250 = iprot.readI64();
14748 
            self.success.append(_elem250)
4008 mandeep.dh 14749 
          iprot.readListEnd()
14750 
        else:
14751 
          iprot.skip(ftype)
14752 
      else:
14753 
        iprot.skip(ftype)
14754 
      iprot.readFieldEnd()
14755 
    iprot.readStructEnd()
14756 
 
14757 
  def write(self, oprot):
14758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14760 
      return
14761 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14762 
    if self.success is not None:
14763 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14764 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14765 
      for iter251 in self.success:
14766 
        oprot.writeI64(iter251)
4008 mandeep.dh 14767 
      oprot.writeListEnd()
14768 
      oprot.writeFieldEnd()
14769 
    oprot.writeFieldStop()
14770 
    oprot.writeStructEnd()
14771 
 
14772 
  def validate(self):
14773 
    return
14774 
 
14775 
 
14776 
  def __repr__(self):
14777 
    L = ['%s=%r' % (key, value)
14778 
      for key, value in self.__dict__.iteritems()]
14779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14780 
 
14781 
  def __eq__(self, other):
14782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14783 
 
14784 
  def __ne__(self, other):
14785 
    return not (self == other)
14786 
 
14787 
class markTransactionAsProcessed_args:
14788 
  """
14789 
  Attributes:
14790 
   - transactionId
14791 
   - category
14792 
  """
14793 
 
14794 
  thrift_spec = (
14795 
    None, # 0
14796 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14797 
    (2, TType.I32, 'category', None, None, ), # 2
14798 
  )
14799 
 
14800 
  def __init__(self, transactionId=None, category=None,):
14801 
    self.transactionId = transactionId
14802 
    self.category = category
14803 
 
14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
14813 
      if fid == 1:
14814 
        if ftype == TType.I64:
14815 
          self.transactionId = iprot.readI64();
14816 
        else:
14817 
          iprot.skip(ftype)
14818 
      elif fid == 2:
14819 
        if ftype == TType.I32:
14820 
          self.category = iprot.readI32();
14821 
        else:
14822 
          iprot.skip(ftype)
14823 
      else:
14824 
        iprot.skip(ftype)
14825 
      iprot.readFieldEnd()
14826 
    iprot.readStructEnd()
14827 
 
14828 
  def write(self, oprot):
14829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14831 
      return
14832 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14833 
    if self.transactionId is not None:
14834 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14835 
      oprot.writeI64(self.transactionId)
14836 
      oprot.writeFieldEnd()
14837 
    if self.category is not None:
14838 
      oprot.writeFieldBegin('category', TType.I32, 2)
14839 
      oprot.writeI32(self.category)
14840 
      oprot.writeFieldEnd()
14841 
    oprot.writeFieldStop()
14842 
    oprot.writeStructEnd()
14843 
 
14844 
  def validate(self):
14845 
    return
14846 
 
14847 
 
14848 
  def __repr__(self):
14849 
    L = ['%s=%r' % (key, value)
14850 
      for key, value in self.__dict__.iteritems()]
14851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14852 
 
14853 
  def __eq__(self, other):
14854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14855 
 
14856 
  def __ne__(self, other):
14857 
    return not (self == other)
14858 
 
14859 
class markTransactionAsProcessed_result:
14860 
 
14861 
  thrift_spec = (
14862 
  )
14863 
 
14864 
  def read(self, iprot):
14865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14867 
      return
14868 
    iprot.readStructBegin()
14869 
    while True:
14870 
      (fname, ftype, fid) = iprot.readFieldBegin()
14871 
      if ftype == TType.STOP:
14872 
        break
14873 
      else:
14874 
        iprot.skip(ftype)
14875 
      iprot.readFieldEnd()
14876 
    iprot.readStructEnd()
14877 
 
14878 
  def write(self, oprot):
14879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14881 
      return
14882 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14883 
    oprot.writeFieldStop()
14884 
    oprot.writeStructEnd()
14885 
 
14886 
  def validate(self):
14887 
    return
14888 
 
14889 
 
14890 
  def __repr__(self):
14891 
    L = ['%s=%r' % (key, value)
14892 
      for key, value in self.__dict__.iteritems()]
14893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14894 
 
14895 
  def __eq__(self, other):
14896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14897 
 
14898 
  def __ne__(self, other):
14899 
    return not (self == other)
4018 chandransh 14900 
 
14901 
class getItemWiseRiskyOrdersCount_args:
14902 
 
14903 
  thrift_spec = (
14904 
  )
14905 
 
14906 
  def read(self, iprot):
14907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14909 
      return
14910 
    iprot.readStructBegin()
14911 
    while True:
14912 
      (fname, ftype, fid) = iprot.readFieldBegin()
14913 
      if ftype == TType.STOP:
14914 
        break
14915 
      else:
14916 
        iprot.skip(ftype)
14917 
      iprot.readFieldEnd()
14918 
    iprot.readStructEnd()
14919 
 
14920 
  def write(self, oprot):
14921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14923 
      return
14924 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14925 
    oprot.writeFieldStop()
14926 
    oprot.writeStructEnd()
14927 
 
14928 
  def validate(self):
14929 
    return
14930 
 
14931 
 
14932 
  def __repr__(self):
14933 
    L = ['%s=%r' % (key, value)
14934 
      for key, value in self.__dict__.iteritems()]
14935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14936 
 
14937 
  def __eq__(self, other):
14938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14939 
 
14940 
  def __ne__(self, other):
14941 
    return not (self == other)
14942 
 
14943 
class getItemWiseRiskyOrdersCount_result:
14944 
  """
14945 
  Attributes:
14946 
   - success
14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14951 
  )
14952 
 
14953 
  def __init__(self, success=None,):
14954 
    self.success = success
14955 
 
14956 
  def read(self, iprot):
14957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14959 
      return
14960 
    iprot.readStructBegin()
14961 
    while True:
14962 
      (fname, ftype, fid) = iprot.readFieldBegin()
14963 
      if ftype == TType.STOP:
14964 
        break
14965 
      if fid == 0:
14966 
        if ftype == TType.MAP:
14967 
          self.success = {}
4586 mandeep.dh 14968 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
14969 
          for _i256 in xrange(_size252):
14970 
            _key257 = iprot.readI64();
14971 
            _val258 = iprot.readI64();
14972 
            self.success[_key257] = _val258
4018 chandransh 14973 
          iprot.readMapEnd()
14974 
        else:
14975 
          iprot.skip(ftype)
14976 
      else:
14977 
        iprot.skip(ftype)
14978 
      iprot.readFieldEnd()
14979 
    iprot.readStructEnd()
14980 
 
14981 
  def write(self, oprot):
14982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14984 
      return
14985 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14986 
    if self.success is not None:
14987 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14988 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 14989 
      for kiter259,viter260 in self.success.items():
14990 
        oprot.writeI64(kiter259)
14991 
        oprot.writeI64(viter260)
4018 chandransh 14992 
      oprot.writeMapEnd()
14993 
      oprot.writeFieldEnd()
14994 
    oprot.writeFieldStop()
14995 
    oprot.writeStructEnd()
14996 
 
14997 
  def validate(self):
14998 
    return
14999 
 
15000 
 
15001 
  def __repr__(self):
15002 
    L = ['%s=%r' % (key, value)
15003 
      for key, value in self.__dict__.iteritems()]
15004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15005 
 
15006 
  def __eq__(self, other):
15007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15008 
 
15009 
  def __ne__(self, other):
15010 
    return not (self == other)
4247 rajveer 15011 
 
4295 varun.gupt 15012 
class getOrdersForItemIds_args:
15013 
  """
15014 
  Attributes:
15015 
   - itemIds
15016 
  """
15017 
 
15018 
  thrift_spec = (
15019 
    None, # 0
15020 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15021 
  )
15022 
 
15023 
  def __init__(self, itemIds=None,):
15024 
    self.itemIds = itemIds
15025 
 
15026 
  def read(self, iprot):
15027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15029 
      return
15030 
    iprot.readStructBegin()
15031 
    while True:
15032 
      (fname, ftype, fid) = iprot.readFieldBegin()
15033 
      if ftype == TType.STOP:
15034 
        break
15035 
      if fid == 1:
15036 
        if ftype == TType.LIST:
15037 
          self.itemIds = []
4586 mandeep.dh 15038 
          (_etype264, _size261) = iprot.readListBegin()
15039 
          for _i265 in xrange(_size261):
15040 
            _elem266 = iprot.readI64();
15041 
            self.itemIds.append(_elem266)
4295 varun.gupt 15042 
          iprot.readListEnd()
15043 
        else:
15044 
          iprot.skip(ftype)
15045 
      else:
15046 
        iprot.skip(ftype)
15047 
      iprot.readFieldEnd()
15048 
    iprot.readStructEnd()
15049 
 
15050 
  def write(self, oprot):
15051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15053 
      return
15054 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15055 
    if self.itemIds is not None:
15056 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15057 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15058 
      for iter267 in self.itemIds:
15059 
        oprot.writeI64(iter267)
4295 varun.gupt 15060 
      oprot.writeListEnd()
15061 
      oprot.writeFieldEnd()
15062 
    oprot.writeFieldStop()
15063 
    oprot.writeStructEnd()
15064 
 
15065 
  def validate(self):
15066 
    return
15067 
 
15068 
 
15069 
  def __repr__(self):
15070 
    L = ['%s=%r' % (key, value)
15071 
      for key, value in self.__dict__.iteritems()]
15072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15073 
 
15074 
  def __eq__(self, other):
15075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15076 
 
15077 
  def __ne__(self, other):
15078 
    return not (self == other)
15079 
 
15080 
class getOrdersForItemIds_result:
15081 
  """
15082 
  Attributes:
15083 
   - success
15084 
  """
15085 
 
15086 
  thrift_spec = (
15087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15088 
  )
15089 
 
15090 
  def __init__(self, success=None,):
15091 
    self.success = success
15092 
 
15093 
  def read(self, iprot):
15094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15096 
      return
15097 
    iprot.readStructBegin()
15098 
    while True:
15099 
      (fname, ftype, fid) = iprot.readFieldBegin()
15100 
      if ftype == TType.STOP:
15101 
        break
15102 
      if fid == 0:
15103 
        if ftype == TType.LIST:
15104 
          self.success = []
4586 mandeep.dh 15105 
          (_etype271, _size268) = iprot.readListBegin()
15106 
          for _i272 in xrange(_size268):
15107 
            _elem273 = Order()
15108 
            _elem273.read(iprot)
15109 
            self.success.append(_elem273)
4295 varun.gupt 15110 
          iprot.readListEnd()
15111 
        else:
15112 
          iprot.skip(ftype)
15113 
      else:
15114 
        iprot.skip(ftype)
15115 
      iprot.readFieldEnd()
15116 
    iprot.readStructEnd()
15117 
 
15118 
  def write(self, oprot):
15119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15121 
      return
15122 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15123 
    if self.success is not None:
15124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15126 
      for iter274 in self.success:
15127 
        iter274.write(oprot)
4295 varun.gupt 15128 
      oprot.writeListEnd()
15129 
      oprot.writeFieldEnd()
15130 
    oprot.writeFieldStop()
15131 
    oprot.writeStructEnd()
15132 
 
15133 
  def validate(self):
15134 
    return
15135 
 
15136 
 
15137 
  def __repr__(self):
15138 
    L = ['%s=%r' % (key, value)
15139 
      for key, value in self.__dict__.iteritems()]
15140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15141 
 
15142 
  def __eq__(self, other):
15143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15144 
 
15145 
  def __ne__(self, other):
15146 
    return not (self == other)
15147 
 
4247 rajveer 15148 
class markOrderCancellationRequestReceived_args:
15149 
  """
15150 
  Attributes:
15151 
   - orderId
15152 
  """
15153 
 
15154 
  thrift_spec = (
15155 
    None, # 0
15156 
    (1, TType.I64, 'orderId', None, None, ), # 1
15157 
  )
15158 
 
15159 
  def __init__(self, orderId=None,):
15160 
    self.orderId = orderId
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 1:
15172 
        if ftype == TType.I64:
15173 
          self.orderId = iprot.readI64();
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      else:
15177 
        iprot.skip(ftype)
15178 
      iprot.readFieldEnd()
15179 
    iprot.readStructEnd()
15180 
 
15181 
  def write(self, oprot):
15182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15184 
      return
15185 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15186 
    if self.orderId is not None:
15187 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15188 
      oprot.writeI64(self.orderId)
15189 
      oprot.writeFieldEnd()
15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
15207 
 
15208 
class markOrderCancellationRequestReceived_result:
15209 
  """
15210 
  Attributes:
15211 
   - ex
15212 
  """
15213 
 
15214 
  thrift_spec = (
15215 
    None, # 0
15216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15217 
  )
15218 
 
15219 
  def __init__(self, ex=None,):
15220 
    self.ex = ex
15221 
 
15222 
  def read(self, iprot):
15223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15225 
      return
15226 
    iprot.readStructBegin()
15227 
    while True:
15228 
      (fname, ftype, fid) = iprot.readFieldBegin()
15229 
      if ftype == TType.STOP:
15230 
        break
15231 
      if fid == 1:
15232 
        if ftype == TType.STRUCT:
15233 
          self.ex = TransactionServiceException()
15234 
          self.ex.read(iprot)
15235 
        else:
15236 
          iprot.skip(ftype)
15237 
      else:
15238 
        iprot.skip(ftype)
15239 
      iprot.readFieldEnd()
15240 
    iprot.readStructEnd()
15241 
 
15242 
  def write(self, oprot):
15243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15245 
      return
15246 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15247 
    if self.ex is not None:
15248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15249 
      self.ex.write(oprot)
15250 
      oprot.writeFieldEnd()
15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
15269 
class markOrderCancellationRequestConfirmed_args:
15270 
  """
15271 
  Attributes:
15272 
   - orderId
15273 
  """
15274 
 
15275 
  thrift_spec = (
15276 
    None, # 0
15277 
    (1, TType.I64, 'orderId', None, None, ), # 1
15278 
  )
15279 
 
15280 
  def __init__(self, orderId=None,):
15281 
    self.orderId = orderId
15282 
 
15283 
  def read(self, iprot):
15284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15286 
      return
15287 
    iprot.readStructBegin()
15288 
    while True:
15289 
      (fname, ftype, fid) = iprot.readFieldBegin()
15290 
      if ftype == TType.STOP:
15291 
        break
15292 
      if fid == 1:
15293 
        if ftype == TType.I64:
15294 
          self.orderId = iprot.readI64();
15295 
        else:
15296 
          iprot.skip(ftype)
15297 
      else:
15298 
        iprot.skip(ftype)
15299 
      iprot.readFieldEnd()
15300 
    iprot.readStructEnd()
15301 
 
15302 
  def write(self, oprot):
15303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15305 
      return
15306 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15307 
    if self.orderId is not None:
15308 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15309 
      oprot.writeI64(self.orderId)
15310 
      oprot.writeFieldEnd()
15311 
    oprot.writeFieldStop()
15312 
    oprot.writeStructEnd()
15313 
 
15314 
  def validate(self):
15315 
    return
15316 
 
15317 
 
15318 
  def __repr__(self):
15319 
    L = ['%s=%r' % (key, value)
15320 
      for key, value in self.__dict__.iteritems()]
15321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15322 
 
15323 
  def __eq__(self, other):
15324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15325 
 
15326 
  def __ne__(self, other):
15327 
    return not (self == other)
15328 
 
15329 
class markOrderCancellationRequestConfirmed_result:
15330 
  """
15331 
  Attributes:
15332 
   - ex
15333 
  """
15334 
 
15335 
  thrift_spec = (
15336 
    None, # 0
15337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15338 
  )
15339 
 
15340 
  def __init__(self, ex=None,):
15341 
    self.ex = ex
15342 
 
15343 
  def read(self, iprot):
15344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15346 
      return
15347 
    iprot.readStructBegin()
15348 
    while True:
15349 
      (fname, ftype, fid) = iprot.readFieldBegin()
15350 
      if ftype == TType.STOP:
15351 
        break
15352 
      if fid == 1:
15353 
        if ftype == TType.STRUCT:
15354 
          self.ex = TransactionServiceException()
15355 
          self.ex.read(iprot)
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15368 
    if self.ex is not None:
15369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15370 
      self.ex.write(oprot)
15371 
      oprot.writeFieldEnd()
15372 
    oprot.writeFieldStop()
15373 
    oprot.writeStructEnd()
15374 
 
15375 
  def validate(self):
15376 
    return
15377 
 
15378 
 
15379 
  def __repr__(self):
15380 
    L = ['%s=%r' % (key, value)
15381 
      for key, value in self.__dict__.iteritems()]
15382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15383 
 
15384 
  def __eq__(self, other):
15385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15386 
 
15387 
  def __ne__(self, other):
15388 
    return not (self == other)
15389 
 
15390 
class markOrderCancellationRequestDenied_args:
15391 
  """
15392 
  Attributes:
15393 
   - orderId
15394 
  """
15395 
 
15396 
  thrift_spec = (
15397 
    None, # 0
15398 
    (1, TType.I64, 'orderId', None, None, ), # 1
15399 
  )
15400 
 
15401 
  def __init__(self, orderId=None,):
15402 
    self.orderId = orderId
15403 
 
15404 
  def read(self, iprot):
15405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15407 
      return
15408 
    iprot.readStructBegin()
15409 
    while True:
15410 
      (fname, ftype, fid) = iprot.readFieldBegin()
15411 
      if ftype == TType.STOP:
15412 
        break
15413 
      if fid == 1:
15414 
        if ftype == TType.I64:
15415 
          self.orderId = iprot.readI64();
15416 
        else:
15417 
          iprot.skip(ftype)
15418 
      else:
15419 
        iprot.skip(ftype)
15420 
      iprot.readFieldEnd()
15421 
    iprot.readStructEnd()
15422 
 
15423 
  def write(self, oprot):
15424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15426 
      return
15427 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15428 
    if self.orderId is not None:
15429 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15430 
      oprot.writeI64(self.orderId)
15431 
      oprot.writeFieldEnd()
15432 
    oprot.writeFieldStop()
15433 
    oprot.writeStructEnd()
15434 
 
15435 
  def validate(self):
15436 
    return
15437 
 
15438 
 
15439 
  def __repr__(self):
15440 
    L = ['%s=%r' % (key, value)
15441 
      for key, value in self.__dict__.iteritems()]
15442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15443 
 
15444 
  def __eq__(self, other):
15445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15446 
 
15447 
  def __ne__(self, other):
15448 
    return not (self == other)
15449 
 
15450 
class markOrderCancellationRequestDenied_result:
15451 
  """
15452 
  Attributes:
15453 
   - ex
15454 
  """
15455 
 
15456 
  thrift_spec = (
15457 
    None, # 0
15458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15459 
  )
15460 
 
15461 
  def __init__(self, ex=None,):
15462 
    self.ex = ex
15463 
 
15464 
  def read(self, iprot):
15465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15467 
      return
15468 
    iprot.readStructBegin()
15469 
    while True:
15470 
      (fname, ftype, fid) = iprot.readFieldBegin()
15471 
      if ftype == TType.STOP:
15472 
        break
15473 
      if fid == 1:
15474 
        if ftype == TType.STRUCT:
15475 
          self.ex = TransactionServiceException()
15476 
          self.ex.read(iprot)
15477 
        else:
15478 
          iprot.skip(ftype)
15479 
      else:
15480 
        iprot.skip(ftype)
15481 
      iprot.readFieldEnd()
15482 
    iprot.readStructEnd()
15483 
 
15484 
  def write(self, oprot):
15485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15487 
      return
15488 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15489 
    if self.ex is not None:
15490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15491 
      self.ex.write(oprot)
15492 
      oprot.writeFieldEnd()
15493 
    oprot.writeFieldStop()
15494 
    oprot.writeStructEnd()
15495 
 
15496 
  def validate(self):
15497 
    return
15498 
 
15499 
 
15500 
  def __repr__(self):
15501 
    L = ['%s=%r' % (key, value)
15502 
      for key, value in self.__dict__.iteritems()]
15503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15504 
 
15505 
  def __eq__(self, other):
15506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15507 
 
15508 
  def __ne__(self, other):
15509 
    return not (self == other)
15510 
 
4258 rajveer 15511 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15512 
  """
15513 
  Attributes:
4258 rajveer 15514 
   - transactionId
4247 rajveer 15515 
  """
15516 
 
15517 
  thrift_spec = (
15518 
    None, # 0
4258 rajveer 15519 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15520 
  )
15521 
 
4258 rajveer 15522 
  def __init__(self, transactionId=None,):
15523 
    self.transactionId = transactionId
4247 rajveer 15524 
 
15525 
  def read(self, iprot):
15526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15528 
      return
15529 
    iprot.readStructBegin()
15530 
    while True:
15531 
      (fname, ftype, fid) = iprot.readFieldBegin()
15532 
      if ftype == TType.STOP:
15533 
        break
15534 
      if fid == 1:
15535 
        if ftype == TType.I64:
4258 rajveer 15536 
          self.transactionId = iprot.readI64();
4247 rajveer 15537 
        else:
15538 
          iprot.skip(ftype)
15539 
      else:
15540 
        iprot.skip(ftype)
15541 
      iprot.readFieldEnd()
15542 
    iprot.readStructEnd()
15543 
 
15544 
  def write(self, oprot):
15545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15547 
      return
4258 rajveer 15548 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15549 
    if self.transactionId is not None:
15550 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15551 
      oprot.writeI64(self.transactionId)
4247 rajveer 15552 
      oprot.writeFieldEnd()
15553 
    oprot.writeFieldStop()
15554 
    oprot.writeStructEnd()
15555 
 
15556 
  def validate(self):
15557 
    return
15558 
 
15559 
 
15560 
  def __repr__(self):
15561 
    L = ['%s=%r' % (key, value)
15562 
      for key, value in self.__dict__.iteritems()]
15563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15564 
 
15565 
  def __eq__(self, other):
15566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15567 
 
15568 
  def __ne__(self, other):
15569 
    return not (self == other)
15570 
 
4258 rajveer 15571 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15572 
  """
15573 
  Attributes:
15574 
   - ex
15575 
  """
15576 
 
15577 
  thrift_spec = (
15578 
    None, # 0
15579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15580 
  )
15581 
 
15582 
  def __init__(self, ex=None,):
15583 
    self.ex = ex
15584 
 
15585 
  def read(self, iprot):
15586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15588 
      return
15589 
    iprot.readStructBegin()
15590 
    while True:
15591 
      (fname, ftype, fid) = iprot.readFieldBegin()
15592 
      if ftype == TType.STOP:
15593 
        break
15594 
      if fid == 1:
15595 
        if ftype == TType.STRUCT:
15596 
          self.ex = TransactionServiceException()
15597 
          self.ex.read(iprot)
15598 
        else:
15599 
          iprot.skip(ftype)
15600 
      else:
15601 
        iprot.skip(ftype)
15602 
      iprot.readFieldEnd()
15603 
    iprot.readStructEnd()
15604 
 
15605 
  def write(self, oprot):
15606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15608 
      return
4258 rajveer 15609 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15610 
    if self.ex is not None:
15611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15612 
      self.ex.write(oprot)
15613 
      oprot.writeFieldEnd()
15614 
    oprot.writeFieldStop()
15615 
    oprot.writeStructEnd()
15616 
 
15617 
  def validate(self):
15618 
    return
15619 
 
15620 
 
15621 
  def __repr__(self):
15622 
    L = ['%s=%r' % (key, value)
15623 
      for key, value in self.__dict__.iteritems()]
15624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15625 
 
15626 
  def __eq__(self, other):
15627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15628 
 
15629 
  def __ne__(self, other):
15630 
    return not (self == other)
4259 anupam.sin 15631 
 
15632 
class refundTransaction_args:
15633 
  """
15634 
  Attributes:
15635 
   - transactionId
15636 
   - refundedBy
15637 
   - reason
15638 
  """
15639 
 
15640 
  thrift_spec = (
15641 
    None, # 0
15642 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15643 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15644 
    (3, TType.STRING, 'reason', None, None, ), # 3
15645 
  )
15646 
 
15647 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15648 
    self.transactionId = transactionId
15649 
    self.refundedBy = refundedBy
15650 
    self.reason = reason
15651 
 
15652 
  def read(self, iprot):
15653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15655 
      return
15656 
    iprot.readStructBegin()
15657 
    while True:
15658 
      (fname, ftype, fid) = iprot.readFieldBegin()
15659 
      if ftype == TType.STOP:
15660 
        break
15661 
      if fid == 1:
15662 
        if ftype == TType.I64:
15663 
          self.transactionId = iprot.readI64();
15664 
        else:
15665 
          iprot.skip(ftype)
15666 
      elif fid == 2:
15667 
        if ftype == TType.STRING:
15668 
          self.refundedBy = iprot.readString();
15669 
        else:
15670 
          iprot.skip(ftype)
15671 
      elif fid == 3:
15672 
        if ftype == TType.STRING:
15673 
          self.reason = iprot.readString();
15674 
        else:
15675 
          iprot.skip(ftype)
15676 
      else:
15677 
        iprot.skip(ftype)
15678 
      iprot.readFieldEnd()
15679 
    iprot.readStructEnd()
15680 
 
15681 
  def write(self, oprot):
15682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15684 
      return
15685 
    oprot.writeStructBegin('refundTransaction_args')
15686 
    if self.transactionId is not None:
15687 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15688 
      oprot.writeI64(self.transactionId)
15689 
      oprot.writeFieldEnd()
15690 
    if self.refundedBy is not None:
15691 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15692 
      oprot.writeString(self.refundedBy)
15693 
      oprot.writeFieldEnd()
15694 
    if self.reason is not None:
15695 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15696 
      oprot.writeString(self.reason)
15697 
      oprot.writeFieldEnd()
15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
15715 
 
15716 
class refundTransaction_result:
15717 
  """
15718 
  Attributes:
15719 
   - ex
15720 
  """
15721 
 
15722 
  thrift_spec = (
15723 
    None, # 0
15724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15725 
  )
15726 
 
15727 
  def __init__(self, ex=None,):
15728 
    self.ex = ex
15729 
 
15730 
  def read(self, iprot):
15731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15733 
      return
15734 
    iprot.readStructBegin()
15735 
    while True:
15736 
      (fname, ftype, fid) = iprot.readFieldBegin()
15737 
      if ftype == TType.STOP:
15738 
        break
15739 
      if fid == 1:
15740 
        if ftype == TType.STRUCT:
15741 
          self.ex = TransactionServiceException()
15742 
          self.ex.read(iprot)
15743 
        else:
15744 
          iprot.skip(ftype)
15745 
      else:
15746 
        iprot.skip(ftype)
15747 
      iprot.readFieldEnd()
15748 
    iprot.readStructEnd()
15749 
 
15750 
  def write(self, oprot):
15751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15753 
      return
15754 
    oprot.writeStructBegin('refundTransaction_result')
15755 
    if self.ex is not None:
15756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15757 
      self.ex.write(oprot)
15758 
      oprot.writeFieldEnd()
15759 
    oprot.writeFieldStop()
15760 
    oprot.writeStructEnd()
15761 
 
15762 
  def validate(self):
15763 
    return
15764 
 
15765 
 
15766 
  def __repr__(self):
15767 
    L = ['%s=%r' % (key, value)
15768 
      for key, value in self.__dict__.iteritems()]
15769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15770 
 
15771 
  def __eq__(self, other):
15772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15773 
 
15774 
  def __ne__(self, other):
15775 
    return not (self == other)
4285 rajveer 15776 
 
4324 mandeep.dh 15777 
class updateShipmentAddress_args:
15778 
  """
15779 
  Attributes:
15780 
   - orderId
15781 
   - addressId
15782 
  """
15783 
 
15784 
  thrift_spec = (
15785 
    None, # 0
15786 
    (1, TType.I64, 'orderId', None, None, ), # 1
15787 
    (2, TType.I64, 'addressId', None, None, ), # 2
15788 
  )
15789 
 
15790 
  def __init__(self, orderId=None, addressId=None,):
15791 
    self.orderId = orderId
15792 
    self.addressId = addressId
15793 
 
15794 
  def read(self, iprot):
15795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15797 
      return
15798 
    iprot.readStructBegin()
15799 
    while True:
15800 
      (fname, ftype, fid) = iprot.readFieldBegin()
15801 
      if ftype == TType.STOP:
15802 
        break
15803 
      if fid == 1:
15804 
        if ftype == TType.I64:
15805 
          self.orderId = iprot.readI64();
15806 
        else:
15807 
          iprot.skip(ftype)
15808 
      elif fid == 2:
15809 
        if ftype == TType.I64:
15810 
          self.addressId = iprot.readI64();
15811 
        else:
15812 
          iprot.skip(ftype)
15813 
      else:
15814 
        iprot.skip(ftype)
15815 
      iprot.readFieldEnd()
15816 
    iprot.readStructEnd()
15817 
 
15818 
  def write(self, oprot):
15819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15821 
      return
15822 
    oprot.writeStructBegin('updateShipmentAddress_args')
15823 
    if self.orderId is not None:
15824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15825 
      oprot.writeI64(self.orderId)
15826 
      oprot.writeFieldEnd()
15827 
    if self.addressId is not None:
15828 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15829 
      oprot.writeI64(self.addressId)
15830 
      oprot.writeFieldEnd()
15831 
    oprot.writeFieldStop()
15832 
    oprot.writeStructEnd()
15833 
 
15834 
  def validate(self):
15835 
    return
15836 
 
15837 
 
15838 
  def __repr__(self):
15839 
    L = ['%s=%r' % (key, value)
15840 
      for key, value in self.__dict__.iteritems()]
15841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15842 
 
15843 
  def __eq__(self, other):
15844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15845 
 
15846 
  def __ne__(self, other):
15847 
    return not (self == other)
15848 
 
15849 
class updateShipmentAddress_result:
15850 
  """
15851 
  Attributes:
15852 
   - ex
15853 
  """
15854 
 
15855 
  thrift_spec = (
15856 
    None, # 0
15857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15858 
  )
15859 
 
15860 
  def __init__(self, ex=None,):
15861 
    self.ex = ex
15862 
 
15863 
  def read(self, iprot):
15864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15866 
      return
15867 
    iprot.readStructBegin()
15868 
    while True:
15869 
      (fname, ftype, fid) = iprot.readFieldBegin()
15870 
      if ftype == TType.STOP:
15871 
        break
15872 
      if fid == 1:
15873 
        if ftype == TType.STRUCT:
15874 
          self.ex = TransactionServiceException()
15875 
          self.ex.read(iprot)
15876 
        else:
15877 
          iprot.skip(ftype)
15878 
      else:
15879 
        iprot.skip(ftype)
15880 
      iprot.readFieldEnd()
15881 
    iprot.readStructEnd()
15882 
 
15883 
  def write(self, oprot):
15884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15886 
      return
15887 
    oprot.writeStructBegin('updateShipmentAddress_result')
15888 
    if self.ex is not None:
15889 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15890 
      self.ex.write(oprot)
15891 
      oprot.writeFieldEnd()
15892 
    oprot.writeFieldStop()
15893 
    oprot.writeStructEnd()
15894 
 
15895 
  def validate(self):
15896 
    return
15897 
 
15898 
 
15899 
  def __repr__(self):
15900 
    L = ['%s=%r' % (key, value)
15901 
      for key, value in self.__dict__.iteritems()]
15902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15903 
 
15904 
  def __eq__(self, other):
15905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15906 
 
15907 
  def __ne__(self, other):
15908 
    return not (self == other)
15909 
 
4285 rajveer 15910 
class acceptOrdersForItemId_args:
15911 
  """
15912 
  Attributes:
15913 
   - itemId
15914 
   - inventory
15915 
  """
15916 
 
15917 
  thrift_spec = (
15918 
    None, # 0
15919 
    (1, TType.I64, 'itemId', None, None, ), # 1
15920 
    (2, TType.I64, 'inventory', None, None, ), # 2
15921 
  )
15922 
 
15923 
  def __init__(self, itemId=None, inventory=None,):
15924 
    self.itemId = itemId
15925 
    self.inventory = inventory
15926 
 
15927 
  def read(self, iprot):
15928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15930 
      return
15931 
    iprot.readStructBegin()
15932 
    while True:
15933 
      (fname, ftype, fid) = iprot.readFieldBegin()
15934 
      if ftype == TType.STOP:
15935 
        break
15936 
      if fid == 1:
15937 
        if ftype == TType.I64:
15938 
          self.itemId = iprot.readI64();
15939 
        else:
15940 
          iprot.skip(ftype)
15941 
      elif fid == 2:
15942 
        if ftype == TType.I64:
15943 
          self.inventory = iprot.readI64();
15944 
        else:
15945 
          iprot.skip(ftype)
15946 
      else:
15947 
        iprot.skip(ftype)
15948 
      iprot.readFieldEnd()
15949 
    iprot.readStructEnd()
15950 
 
15951 
  def write(self, oprot):
15952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15954 
      return
15955 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15956 
    if self.itemId is not None:
15957 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15958 
      oprot.writeI64(self.itemId)
15959 
      oprot.writeFieldEnd()
15960 
    if self.inventory is not None:
15961 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15962 
      oprot.writeI64(self.inventory)
15963 
      oprot.writeFieldEnd()
15964 
    oprot.writeFieldStop()
15965 
    oprot.writeStructEnd()
15966 
 
15967 
  def validate(self):
15968 
    return
15969 
 
15970 
 
15971 
  def __repr__(self):
15972 
    L = ['%s=%r' % (key, value)
15973 
      for key, value in self.__dict__.iteritems()]
15974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15975 
 
15976 
  def __eq__(self, other):
15977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15978 
 
15979 
  def __ne__(self, other):
15980 
    return not (self == other)
15981 
 
15982 
class acceptOrdersForItemId_result:
15983 
  """
15984 
  Attributes:
15985 
   - success
15986 
   - ex
15987 
  """
15988 
 
15989 
  thrift_spec = (
15990 
    (0, TType.BOOL, 'success', None, None, ), # 0
15991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15992 
  )
15993 
 
15994 
  def __init__(self, success=None, ex=None,):
15995 
    self.success = success
15996 
    self.ex = ex
15997 
 
15998 
  def read(self, iprot):
15999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16001 
      return
16002 
    iprot.readStructBegin()
16003 
    while True:
16004 
      (fname, ftype, fid) = iprot.readFieldBegin()
16005 
      if ftype == TType.STOP:
16006 
        break
16007 
      if fid == 0:
16008 
        if ftype == TType.BOOL:
16009 
          self.success = iprot.readBool();
16010 
        else:
16011 
          iprot.skip(ftype)
16012 
      elif fid == 1:
16013 
        if ftype == TType.STRUCT:
16014 
          self.ex = TransactionServiceException()
16015 
          self.ex.read(iprot)
16016 
        else:
16017 
          iprot.skip(ftype)
16018 
      else:
16019 
        iprot.skip(ftype)
16020 
      iprot.readFieldEnd()
16021 
    iprot.readStructEnd()
16022 
 
16023 
  def write(self, oprot):
16024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16026 
      return
16027 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16028 
    if self.success is not None:
16029 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16030 
      oprot.writeBool(self.success)
16031 
      oprot.writeFieldEnd()
16032 
    if self.ex is not None:
16033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16034 
      self.ex.write(oprot)
16035 
      oprot.writeFieldEnd()
16036 
    oprot.writeFieldStop()
16037 
    oprot.writeStructEnd()
16038 
 
16039 
  def validate(self):
16040 
    return
16041 
 
16042 
 
16043 
  def __repr__(self):
16044 
    L = ['%s=%r' % (key, value)
16045 
      for key, value in self.__dict__.iteritems()]
16046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16047 
 
16048 
  def __eq__(self, other):
16049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16050 
 
16051 
  def __ne__(self, other):
16052 
    return not (self == other)
4303 rajveer 16053 
 
16054 
class markOrdersAsPORaised_args:
16055 
  """
16056 
  Attributes:
16057 
   - vendorId
16058 
   - itemId
16059 
   - quantity
16060 
   - estimate
4369 rajveer 16061 
   - isReminder
4303 rajveer 16062 
  """
16063 
 
16064 
  thrift_spec = (
16065 
    None, # 0
16066 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16067 
    (2, TType.I64, 'itemId', None, None, ), # 2
16068 
    (3, TType.I64, 'quantity', None, None, ), # 3
16069 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16070 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16071 
  )
16072 
 
4369 rajveer 16073 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16074 
    self.vendorId = vendorId
16075 
    self.itemId = itemId
16076 
    self.quantity = quantity
16077 
    self.estimate = estimate
4369 rajveer 16078 
    self.isReminder = isReminder
4303 rajveer 16079 
 
16080 
  def read(self, iprot):
16081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16083 
      return
16084 
    iprot.readStructBegin()
16085 
    while True:
16086 
      (fname, ftype, fid) = iprot.readFieldBegin()
16087 
      if ftype == TType.STOP:
16088 
        break
16089 
      if fid == 1:
16090 
        if ftype == TType.I64:
16091 
          self.vendorId = iprot.readI64();
16092 
        else:
16093 
          iprot.skip(ftype)
16094 
      elif fid == 2:
16095 
        if ftype == TType.I64:
16096 
          self.itemId = iprot.readI64();
16097 
        else:
16098 
          iprot.skip(ftype)
16099 
      elif fid == 3:
16100 
        if ftype == TType.I64:
16101 
          self.quantity = iprot.readI64();
16102 
        else:
16103 
          iprot.skip(ftype)
16104 
      elif fid == 4:
16105 
        if ftype == TType.I64:
16106 
          self.estimate = iprot.readI64();
16107 
        else:
16108 
          iprot.skip(ftype)
4369 rajveer 16109 
      elif fid == 5:
16110 
        if ftype == TType.BOOL:
16111 
          self.isReminder = iprot.readBool();
16112 
        else:
16113 
          iprot.skip(ftype)
4303 rajveer 16114 
      else:
16115 
        iprot.skip(ftype)
16116 
      iprot.readFieldEnd()
16117 
    iprot.readStructEnd()
16118 
 
16119 
  def write(self, oprot):
16120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16122 
      return
16123 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16124 
    if self.vendorId is not None:
16125 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16126 
      oprot.writeI64(self.vendorId)
16127 
      oprot.writeFieldEnd()
16128 
    if self.itemId is not None:
16129 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16130 
      oprot.writeI64(self.itemId)
16131 
      oprot.writeFieldEnd()
16132 
    if self.quantity is not None:
16133 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16134 
      oprot.writeI64(self.quantity)
16135 
      oprot.writeFieldEnd()
16136 
    if self.estimate is not None:
16137 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16138 
      oprot.writeI64(self.estimate)
16139 
      oprot.writeFieldEnd()
4369 rajveer 16140 
    if self.isReminder is not None:
16141 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16142 
      oprot.writeBool(self.isReminder)
16143 
      oprot.writeFieldEnd()
4303 rajveer 16144 
    oprot.writeFieldStop()
16145 
    oprot.writeStructEnd()
16146 
 
16147 
  def validate(self):
16148 
    return
16149 
 
16150 
 
16151 
  def __repr__(self):
16152 
    L = ['%s=%r' % (key, value)
16153 
      for key, value in self.__dict__.iteritems()]
16154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16155 
 
16156 
  def __eq__(self, other):
16157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16158 
 
16159 
  def __ne__(self, other):
16160 
    return not (self == other)
16161 
 
16162 
class markOrdersAsPORaised_result:
16163 
  """
16164 
  Attributes:
16165 
   - ex
16166 
  """
16167 
 
16168 
  thrift_spec = (
16169 
    None, # 0
16170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16171 
  )
16172 
 
16173 
  def __init__(self, ex=None,):
16174 
    self.ex = ex
16175 
 
16176 
  def read(self, iprot):
16177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16179 
      return
16180 
    iprot.readStructBegin()
16181 
    while True:
16182 
      (fname, ftype, fid) = iprot.readFieldBegin()
16183 
      if ftype == TType.STOP:
16184 
        break
16185 
      if fid == 1:
16186 
        if ftype == TType.STRUCT:
16187 
          self.ex = TransactionServiceException()
16188 
          self.ex.read(iprot)
16189 
        else:
16190 
          iprot.skip(ftype)
16191 
      else:
16192 
        iprot.skip(ftype)
16193 
      iprot.readFieldEnd()
16194 
    iprot.readStructEnd()
16195 
 
16196 
  def write(self, oprot):
16197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16199 
      return
16200 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16201 
    if self.ex is not None:
16202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16203 
      self.ex.write(oprot)
16204 
      oprot.writeFieldEnd()
16205 
    oprot.writeFieldStop()
16206 
    oprot.writeStructEnd()
16207 
 
16208 
  def validate(self):
16209 
    return
16210 
 
16211 
 
16212 
  def __repr__(self):
16213 
    L = ['%s=%r' % (key, value)
16214 
      for key, value in self.__dict__.iteritems()]
16215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16216 
 
16217 
  def __eq__(self, other):
16218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16219 
 
16220 
  def __ne__(self, other):
16221 
    return not (self == other)
16222 
 
16223 
class markOrdersAsReversalInitiated_args:
16224 
  """
16225 
  Attributes:
16226 
   - vendorId
16227 
   - itemId
16228 
   - quantity
16229 
   - estimate
4369 rajveer 16230 
   - isReminder
4303 rajveer 16231 
  """
16232 
 
16233 
  thrift_spec = (
16234 
    None, # 0
16235 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16236 
    (2, TType.I64, 'itemId', None, None, ), # 2
16237 
    (3, TType.I64, 'quantity', None, None, ), # 3
16238 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16239 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16240 
  )
16241 
 
4369 rajveer 16242 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16243 
    self.vendorId = vendorId
16244 
    self.itemId = itemId
16245 
    self.quantity = quantity
16246 
    self.estimate = estimate
4369 rajveer 16247 
    self.isReminder = isReminder
4303 rajveer 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.I64:
16260 
          self.vendorId = iprot.readI64();
16261 
        else:
16262 
          iprot.skip(ftype)
16263 
      elif fid == 2:
16264 
        if ftype == TType.I64:
16265 
          self.itemId = iprot.readI64();
16266 
        else:
16267 
          iprot.skip(ftype)
16268 
      elif fid == 3:
16269 
        if ftype == TType.I64:
16270 
          self.quantity = iprot.readI64();
16271 
        else:
16272 
          iprot.skip(ftype)
16273 
      elif fid == 4:
16274 
        if ftype == TType.I64:
16275 
          self.estimate = iprot.readI64();
16276 
        else:
16277 
          iprot.skip(ftype)
4369 rajveer 16278 
      elif fid == 5:
16279 
        if ftype == TType.BOOL:
16280 
          self.isReminder = iprot.readBool();
16281 
        else:
16282 
          iprot.skip(ftype)
4303 rajveer 16283 
      else:
16284 
        iprot.skip(ftype)
16285 
      iprot.readFieldEnd()
16286 
    iprot.readStructEnd()
16287 
 
16288 
  def write(self, oprot):
16289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16291 
      return
16292 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16293 
    if self.vendorId is not None:
16294 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16295 
      oprot.writeI64(self.vendorId)
16296 
      oprot.writeFieldEnd()
16297 
    if self.itemId is not None:
16298 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16299 
      oprot.writeI64(self.itemId)
16300 
      oprot.writeFieldEnd()
16301 
    if self.quantity is not None:
16302 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16303 
      oprot.writeI64(self.quantity)
16304 
      oprot.writeFieldEnd()
16305 
    if self.estimate is not None:
16306 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16307 
      oprot.writeI64(self.estimate)
16308 
      oprot.writeFieldEnd()
4369 rajveer 16309 
    if self.isReminder is not None:
16310 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16311 
      oprot.writeBool(self.isReminder)
16312 
      oprot.writeFieldEnd()
4303 rajveer 16313 
    oprot.writeFieldStop()
16314 
    oprot.writeStructEnd()
16315 
 
16316 
  def validate(self):
16317 
    return
16318 
 
16319 
 
16320 
  def __repr__(self):
16321 
    L = ['%s=%r' % (key, value)
16322 
      for key, value in self.__dict__.iteritems()]
16323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16324 
 
16325 
  def __eq__(self, other):
16326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16327 
 
16328 
  def __ne__(self, other):
16329 
    return not (self == other)
16330 
 
16331 
class markOrdersAsReversalInitiated_result:
16332 
  """
16333 
  Attributes:
16334 
   - ex
16335 
  """
16336 
 
16337 
  thrift_spec = (
16338 
    None, # 0
16339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16340 
  )
16341 
 
16342 
  def __init__(self, ex=None,):
16343 
    self.ex = ex
16344 
 
16345 
  def read(self, iprot):
16346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16348 
      return
16349 
    iprot.readStructBegin()
16350 
    while True:
16351 
      (fname, ftype, fid) = iprot.readFieldBegin()
16352 
      if ftype == TType.STOP:
16353 
        break
16354 
      if fid == 1:
16355 
        if ftype == TType.STRUCT:
16356 
          self.ex = TransactionServiceException()
16357 
          self.ex.read(iprot)
16358 
        else:
16359 
          iprot.skip(ftype)
16360 
      else:
16361 
        iprot.skip(ftype)
16362 
      iprot.readFieldEnd()
16363 
    iprot.readStructEnd()
16364 
 
16365 
  def write(self, oprot):
16366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16368 
      return
16369 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16370 
    if self.ex is not None:
16371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16372 
      self.ex.write(oprot)
16373 
      oprot.writeFieldEnd()
16374 
    oprot.writeFieldStop()
16375 
    oprot.writeStructEnd()
16376 
 
16377 
  def validate(self):
16378 
    return
16379 
 
16380 
 
16381 
  def __repr__(self):
16382 
    L = ['%s=%r' % (key, value)
16383 
      for key, value in self.__dict__.iteritems()]
16384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16385 
 
16386 
  def __eq__(self, other):
16387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16388 
 
16389 
  def __ne__(self, other):
16390 
    return not (self == other)
16391 
 
16392 
class markOrdersAsNotAvailabke_args:
16393 
  """
16394 
  Attributes:
16395 
   - vendorId
16396 
   - itemId
16397 
   - quantity
16398 
   - estimate
4369 rajveer 16399 
   - isReminder
4303 rajveer 16400 
  """
16401 
 
16402 
  thrift_spec = (
16403 
    None, # 0
16404 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16405 
    (2, TType.I64, 'itemId', None, None, ), # 2
16406 
    (3, TType.I64, 'quantity', None, None, ), # 3
16407 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16408 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16409 
  )
16410 
 
4369 rajveer 16411 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16412 
    self.vendorId = vendorId
16413 
    self.itemId = itemId
16414 
    self.quantity = quantity
16415 
    self.estimate = estimate
4369 rajveer 16416 
    self.isReminder = isReminder
4303 rajveer 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.I64:
16429 
          self.vendorId = iprot.readI64();
16430 
        else:
16431 
          iprot.skip(ftype)
16432 
      elif fid == 2:
16433 
        if ftype == TType.I64:
16434 
          self.itemId = iprot.readI64();
16435 
        else:
16436 
          iprot.skip(ftype)
16437 
      elif fid == 3:
16438 
        if ftype == TType.I64:
16439 
          self.quantity = iprot.readI64();
16440 
        else:
16441 
          iprot.skip(ftype)
16442 
      elif fid == 4:
16443 
        if ftype == TType.I64:
16444 
          self.estimate = iprot.readI64();
16445 
        else:
16446 
          iprot.skip(ftype)
4369 rajveer 16447 
      elif fid == 5:
16448 
        if ftype == TType.BOOL:
16449 
          self.isReminder = iprot.readBool();
16450 
        else:
16451 
          iprot.skip(ftype)
4303 rajveer 16452 
      else:
16453 
        iprot.skip(ftype)
16454 
      iprot.readFieldEnd()
16455 
    iprot.readStructEnd()
16456 
 
16457 
  def write(self, oprot):
16458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16460 
      return
16461 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16462 
    if self.vendorId is not None:
16463 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16464 
      oprot.writeI64(self.vendorId)
16465 
      oprot.writeFieldEnd()
16466 
    if self.itemId is not None:
16467 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16468 
      oprot.writeI64(self.itemId)
16469 
      oprot.writeFieldEnd()
16470 
    if self.quantity is not None:
16471 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16472 
      oprot.writeI64(self.quantity)
16473 
      oprot.writeFieldEnd()
16474 
    if self.estimate is not None:
16475 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16476 
      oprot.writeI64(self.estimate)
16477 
      oprot.writeFieldEnd()
4369 rajveer 16478 
    if self.isReminder is not None:
16479 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16480 
      oprot.writeBool(self.isReminder)
16481 
      oprot.writeFieldEnd()
4303 rajveer 16482 
    oprot.writeFieldStop()
16483 
    oprot.writeStructEnd()
16484 
 
16485 
  def validate(self):
16486 
    return
16487 
 
16488 
 
16489 
  def __repr__(self):
16490 
    L = ['%s=%r' % (key, value)
16491 
      for key, value in self.__dict__.iteritems()]
16492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16493 
 
16494 
  def __eq__(self, other):
16495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16496 
 
16497 
  def __ne__(self, other):
16498 
    return not (self == other)
16499 
 
16500 
class markOrdersAsNotAvailabke_result:
16501 
  """
16502 
  Attributes:
16503 
   - ex
16504 
  """
16505 
 
16506 
  thrift_spec = (
16507 
    None, # 0
16508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16509 
  )
16510 
 
16511 
  def __init__(self, ex=None,):
16512 
    self.ex = ex
16513 
 
16514 
  def read(self, iprot):
16515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16517 
      return
16518 
    iprot.readStructBegin()
16519 
    while True:
16520 
      (fname, ftype, fid) = iprot.readFieldBegin()
16521 
      if ftype == TType.STOP:
16522 
        break
16523 
      if fid == 1:
16524 
        if ftype == TType.STRUCT:
16525 
          self.ex = TransactionServiceException()
16526 
          self.ex.read(iprot)
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16539 
    if self.ex is not None:
16540 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16541 
      self.ex.write(oprot)
16542 
      oprot.writeFieldEnd()
16543 
    oprot.writeFieldStop()
16544 
    oprot.writeStructEnd()
16545 
 
16546 
  def validate(self):
16547 
    return
16548 
 
16549 
 
16550 
  def __repr__(self):
16551 
    L = ['%s=%r' % (key, value)
16552 
      for key, value in self.__dict__.iteritems()]
16553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16554 
 
16555 
  def __eq__(self, other):
16556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16557 
 
16558 
  def __ne__(self, other):
16559 
    return not (self == other)
4369 rajveer 16560 
 
16561 
class markOrdersAsTimeout_args:
16562 
  """
16563 
  Attributes:
16564 
   - vendorId
16565 
  """
16566 
 
16567 
  thrift_spec = (
16568 
    None, # 0
16569 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16570 
  )
16571 
 
16572 
  def __init__(self, vendorId=None,):
16573 
    self.vendorId = vendorId
16574 
 
16575 
  def read(self, iprot):
16576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16578 
      return
16579 
    iprot.readStructBegin()
16580 
    while True:
16581 
      (fname, ftype, fid) = iprot.readFieldBegin()
16582 
      if ftype == TType.STOP:
16583 
        break
16584 
      if fid == 1:
16585 
        if ftype == TType.I64:
16586 
          self.vendorId = iprot.readI64();
16587 
        else:
16588 
          iprot.skip(ftype)
16589 
      else:
16590 
        iprot.skip(ftype)
16591 
      iprot.readFieldEnd()
16592 
    iprot.readStructEnd()
16593 
 
16594 
  def write(self, oprot):
16595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16597 
      return
16598 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16599 
    if self.vendorId is not None:
16600 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16601 
      oprot.writeI64(self.vendorId)
16602 
      oprot.writeFieldEnd()
16603 
    oprot.writeFieldStop()
16604 
    oprot.writeStructEnd()
16605 
 
16606 
  def validate(self):
16607 
    return
16608 
 
16609 
 
16610 
  def __repr__(self):
16611 
    L = ['%s=%r' % (key, value)
16612 
      for key, value in self.__dict__.iteritems()]
16613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16614 
 
16615 
  def __eq__(self, other):
16616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16617 
 
16618 
  def __ne__(self, other):
16619 
    return not (self == other)
16620 
 
16621 
class markOrdersAsTimeout_result:
16622 
  """
16623 
  Attributes:
16624 
   - success
16625 
   - ex
16626 
  """
16627 
 
16628 
  thrift_spec = (
16629 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16631 
  )
16632 
 
16633 
  def __init__(self, success=None, ex=None,):
16634 
    self.success = success
16635 
    self.ex = ex
16636 
 
16637 
  def read(self, iprot):
16638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16640 
      return
16641 
    iprot.readStructBegin()
16642 
    while True:
16643 
      (fname, ftype, fid) = iprot.readFieldBegin()
16644 
      if ftype == TType.STOP:
16645 
        break
16646 
      if fid == 0:
16647 
        if ftype == TType.MAP:
16648 
          self.success = {}
4586 mandeep.dh 16649 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16650 
          for _i279 in xrange(_size275):
16651 
            _key280 = iprot.readI32();
16652 
            _val281 = TimeoutSummary()
16653 
            _val281.read(iprot)
16654 
            self.success[_key280] = _val281
4369 rajveer 16655 
          iprot.readMapEnd()
16656 
        else:
16657 
          iprot.skip(ftype)
16658 
      elif fid == 1:
16659 
        if ftype == TType.STRUCT:
16660 
          self.ex = TransactionServiceException()
16661 
          self.ex.read(iprot)
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      else:
16665 
        iprot.skip(ftype)
16666 
      iprot.readFieldEnd()
16667 
    iprot.readStructEnd()
16668 
 
16669 
  def write(self, oprot):
16670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16672 
      return
16673 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16674 
    if self.success is not None:
16675 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16676 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16677 
      for kiter282,viter283 in self.success.items():
16678 
        oprot.writeI32(kiter282)
16679 
        viter283.write(oprot)
4369 rajveer 16680 
      oprot.writeMapEnd()
16681 
      oprot.writeFieldEnd()
16682 
    if self.ex is not None:
16683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16684 
      self.ex.write(oprot)
16685 
      oprot.writeFieldEnd()
16686 
    oprot.writeFieldStop()
16687 
    oprot.writeStructEnd()
16688 
 
16689 
  def validate(self):
16690 
    return
16691 
 
16692 
 
16693 
  def __repr__(self):
16694 
    L = ['%s=%r' % (key, value)
16695 
      for key, value in self.__dict__.iteritems()]
16696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16697 
 
16698 
  def __eq__(self, other):
16699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16700 
 
16701 
  def __ne__(self, other):
16702 
    return not (self == other)
4386 anupam.sin 16703 
 
16704 
class getOrderForAwb_args:
16705 
  """
16706 
  Attributes:
16707 
   - awb
16708 
  """
16709 
 
16710 
  thrift_spec = (
16711 
    None, # 0
16712 
    (1, TType.STRING, 'awb', None, None, ), # 1
16713 
  )
16714 
 
16715 
  def __init__(self, awb=None,):
16716 
    self.awb = awb
16717 
 
16718 
  def read(self, iprot):
16719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16721 
      return
16722 
    iprot.readStructBegin()
16723 
    while True:
16724 
      (fname, ftype, fid) = iprot.readFieldBegin()
16725 
      if ftype == TType.STOP:
16726 
        break
16727 
      if fid == 1:
16728 
        if ftype == TType.STRING:
16729 
          self.awb = iprot.readString();
16730 
        else:
16731 
          iprot.skip(ftype)
16732 
      else:
16733 
        iprot.skip(ftype)
16734 
      iprot.readFieldEnd()
16735 
    iprot.readStructEnd()
16736 
 
16737 
  def write(self, oprot):
16738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16740 
      return
16741 
    oprot.writeStructBegin('getOrderForAwb_args')
16742 
    if self.awb is not None:
16743 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16744 
      oprot.writeString(self.awb)
16745 
      oprot.writeFieldEnd()
16746 
    oprot.writeFieldStop()
16747 
    oprot.writeStructEnd()
16748 
 
16749 
  def validate(self):
16750 
    return
16751 
 
16752 
 
16753 
  def __repr__(self):
16754 
    L = ['%s=%r' % (key, value)
16755 
      for key, value in self.__dict__.iteritems()]
16756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16757 
 
16758 
  def __eq__(self, other):
16759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16760 
 
16761 
  def __ne__(self, other):
16762 
    return not (self == other)
16763 
 
16764 
class getOrderForAwb_result:
16765 
  """
16766 
  Attributes:
16767 
   - success
16768 
   - ex
16769 
  """
16770 
 
16771 
  thrift_spec = (
16772 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16774 
  )
16775 
 
16776 
  def __init__(self, success=None, ex=None,):
16777 
    self.success = success
16778 
    self.ex = ex
16779 
 
16780 
  def read(self, iprot):
16781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16783 
      return
16784 
    iprot.readStructBegin()
16785 
    while True:
16786 
      (fname, ftype, fid) = iprot.readFieldBegin()
16787 
      if ftype == TType.STOP:
16788 
        break
16789 
      if fid == 0:
16790 
        if ftype == TType.STRUCT:
16791 
          self.success = Order()
16792 
          self.success.read(iprot)
16793 
        else:
16794 
          iprot.skip(ftype)
16795 
      elif fid == 1:
16796 
        if ftype == TType.STRUCT:
16797 
          self.ex = TransactionServiceException()
16798 
          self.ex.read(iprot)
16799 
        else:
16800 
          iprot.skip(ftype)
16801 
      else:
16802 
        iprot.skip(ftype)
16803 
      iprot.readFieldEnd()
16804 
    iprot.readStructEnd()
16805 
 
16806 
  def write(self, oprot):
16807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16809 
      return
16810 
    oprot.writeStructBegin('getOrderForAwb_result')
16811 
    if self.success is not None:
16812 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16813 
      self.success.write(oprot)
16814 
      oprot.writeFieldEnd()
16815 
    if self.ex is not None:
16816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16817 
      self.ex.write(oprot)
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)
4506 phani.kuma 16836 
 
16837 
class getOrdersForProviderForStatus_args:
16838 
  """
16839 
  Attributes:
16840 
   - logistics_provider_id
16841 
   - order_status
16842 
  """
16843 
 
16844 
  thrift_spec = (
16845 
    None, # 0
16846 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16847 
    (2, TType.I32, 'order_status', None, None, ), # 2
16848 
  )
16849 
 
16850 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16851 
    self.logistics_provider_id = logistics_provider_id
16852 
    self.order_status = order_status
16853 
 
16854 
  def read(self, iprot):
16855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16857 
      return
16858 
    iprot.readStructBegin()
16859 
    while True:
16860 
      (fname, ftype, fid) = iprot.readFieldBegin()
16861 
      if ftype == TType.STOP:
16862 
        break
16863 
      if fid == 1:
16864 
        if ftype == TType.I64:
16865 
          self.logistics_provider_id = iprot.readI64();
16866 
        else:
16867 
          iprot.skip(ftype)
16868 
      elif fid == 2:
16869 
        if ftype == TType.I32:
16870 
          self.order_status = iprot.readI32();
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('getOrdersForProviderForStatus_args')
16883 
    if self.logistics_provider_id is not None:
16884 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16885 
      oprot.writeI64(self.logistics_provider_id)
16886 
      oprot.writeFieldEnd()
16887 
    if self.order_status is not None:
16888 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16889 
      oprot.writeI32(self.order_status)
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 
 
16909 
class getOrdersForProviderForStatus_result:
16910 
  """
16911 
  Attributes:
16912 
   - success
16913 
   - ex
16914 
  """
16915 
 
16916 
  thrift_spec = (
16917 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16919 
  )
16920 
 
16921 
  def __init__(self, success=None, ex=None,):
16922 
    self.success = success
16923 
    self.ex = ex
16924 
 
16925 
  def read(self, iprot):
16926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16928 
      return
16929 
    iprot.readStructBegin()
16930 
    while True:
16931 
      (fname, ftype, fid) = iprot.readFieldBegin()
16932 
      if ftype == TType.STOP:
16933 
        break
16934 
      if fid == 0:
16935 
        if ftype == TType.LIST:
16936 
          self.success = []
4586 mandeep.dh 16937 
          (_etype287, _size284) = iprot.readListBegin()
16938 
          for _i288 in xrange(_size284):
16939 
            _elem289 = Order()
16940 
            _elem289.read(iprot)
16941 
            self.success.append(_elem289)
4506 phani.kuma 16942 
          iprot.readListEnd()
16943 
        else:
16944 
          iprot.skip(ftype)
16945 
      elif fid == 1:
16946 
        if ftype == TType.STRUCT:
16947 
          self.ex = TransactionServiceException()
16948 
          self.ex.read(iprot)
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      else:
16952 
        iprot.skip(ftype)
16953 
      iprot.readFieldEnd()
16954 
    iprot.readStructEnd()
16955 
 
16956 
  def write(self, oprot):
16957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16959 
      return
16960 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16961 
    if self.success is not None:
16962 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16963 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 16964 
      for iter290 in self.success:
16965 
        iter290.write(oprot)
4506 phani.kuma 16966 
      oprot.writeListEnd()
16967 
      oprot.writeFieldEnd()
16968 
    if self.ex is not None:
16969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16970 
      self.ex.write(oprot)
16971 
      oprot.writeFieldEnd()
16972 
    oprot.writeFieldStop()
16973 
    oprot.writeStructEnd()
16974 
 
16975 
  def validate(self):
16976 
    return
16977 
 
16978 
 
16979 
  def __repr__(self):
16980 
    L = ['%s=%r' % (key, value)
16981 
      for key, value in self.__dict__.iteritems()]
16982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16983 
 
16984 
  def __eq__(self, other):
16985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16986 
 
16987 
  def __ne__(self, other):
16988 
    return not (self == other)
4600 varun.gupt 16989 
 
16990 
class getBilledOrdersForVendor_args:
16991 
  """
16992 
  Attributes:
16993 
   - vendorId
16994 
   - billingDateFrom
16995 
   - billingDateTo
16996 
  """
16997 
 
16998 
  thrift_spec = (
16999 
    None, # 0
17000 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17001 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17002 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17003 
  )
17004 
 
17005 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17006 
    self.vendorId = vendorId
17007 
    self.billingDateFrom = billingDateFrom
17008 
    self.billingDateTo = billingDateTo
17009 
 
17010 
  def read(self, iprot):
17011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17013 
      return
17014 
    iprot.readStructBegin()
17015 
    while True:
17016 
      (fname, ftype, fid) = iprot.readFieldBegin()
17017 
      if ftype == TType.STOP:
17018 
        break
17019 
      if fid == 1:
17020 
        if ftype == TType.I64:
17021 
          self.vendorId = iprot.readI64();
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      elif fid == 2:
17025 
        if ftype == TType.I64:
17026 
          self.billingDateFrom = iprot.readI64();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 3:
17030 
        if ftype == TType.I64:
17031 
          self.billingDateTo = iprot.readI64();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      else:
17035 
        iprot.skip(ftype)
17036 
      iprot.readFieldEnd()
17037 
    iprot.readStructEnd()
17038 
 
17039 
  def write(self, oprot):
17040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17042 
      return
17043 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17044 
    if self.vendorId is not None:
17045 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17046 
      oprot.writeI64(self.vendorId)
17047 
      oprot.writeFieldEnd()
17048 
    if self.billingDateFrom is not None:
17049 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17050 
      oprot.writeI64(self.billingDateFrom)
17051 
      oprot.writeFieldEnd()
17052 
    if self.billingDateTo is not None:
17053 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17054 
      oprot.writeI64(self.billingDateTo)
17055 
      oprot.writeFieldEnd()
17056 
    oprot.writeFieldStop()
17057 
    oprot.writeStructEnd()
17058 
 
17059 
  def validate(self):
17060 
    return
17061 
 
17062 
 
17063 
  def __repr__(self):
17064 
    L = ['%s=%r' % (key, value)
17065 
      for key, value in self.__dict__.iteritems()]
17066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17067 
 
17068 
  def __eq__(self, other):
17069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17070 
 
17071 
  def __ne__(self, other):
17072 
    return not (self == other)
17073 
 
17074 
class getBilledOrdersForVendor_result:
17075 
  """
17076 
  Attributes:
17077 
   - success
17078 
   - ex
17079 
  """
17080 
 
17081 
  thrift_spec = (
17082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17084 
  )
17085 
 
17086 
  def __init__(self, success=None, ex=None,):
17087 
    self.success = success
17088 
    self.ex = ex
17089 
 
17090 
  def read(self, iprot):
17091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17093 
      return
17094 
    iprot.readStructBegin()
17095 
    while True:
17096 
      (fname, ftype, fid) = iprot.readFieldBegin()
17097 
      if ftype == TType.STOP:
17098 
        break
17099 
      if fid == 0:
17100 
        if ftype == TType.LIST:
17101 
          self.success = []
17102 
          (_etype294, _size291) = iprot.readListBegin()
17103 
          for _i295 in xrange(_size291):
17104 
            _elem296 = Order()
17105 
            _elem296.read(iprot)
17106 
            self.success.append(_elem296)
17107 
          iprot.readListEnd()
17108 
        else:
17109 
          iprot.skip(ftype)
17110 
      elif fid == 1:
17111 
        if ftype == TType.STRUCT:
17112 
          self.ex = TransactionServiceException()
17113 
          self.ex.read(iprot)
17114 
        else:
17115 
          iprot.skip(ftype)
17116 
      else:
17117 
        iprot.skip(ftype)
17118 
      iprot.readFieldEnd()
17119 
    iprot.readStructEnd()
17120 
 
17121 
  def write(self, oprot):
17122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17124 
      return
17125 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17126 
    if self.success is not None:
17127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17129 
      for iter297 in self.success:
17130 
        iter297.write(oprot)
17131 
      oprot.writeListEnd()
17132 
      oprot.writeFieldEnd()
17133 
    if self.ex is not None:
17134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17135 
      self.ex.write(oprot)
17136 
      oprot.writeFieldEnd()
17137 
    oprot.writeFieldStop()
17138 
    oprot.writeStructEnd()
17139 
 
17140 
  def validate(self):
17141 
    return
17142 
 
17143 
 
17144 
  def __repr__(self):
17145 
    L = ['%s=%r' % (key, value)
17146 
      for key, value in self.__dict__.iteritems()]
17147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17148 
 
17149 
  def __eq__(self, other):
17150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17151 
 
17152 
  def __ne__(self, other):
17153 
    return not (self == other)
17154 
 
4607 rajveer 17155 
class getSlippedSippingDateOrders_args:
17156 
 
17157 
  thrift_spec = (
17158 
  )
17159 
 
17160 
  def read(self, iprot):
17161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17163 
      return
17164 
    iprot.readStructBegin()
17165 
    while True:
17166 
      (fname, ftype, fid) = iprot.readFieldBegin()
17167 
      if ftype == TType.STOP:
17168 
        break
17169 
      else:
17170 
        iprot.skip(ftype)
17171 
      iprot.readFieldEnd()
17172 
    iprot.readStructEnd()
17173 
 
17174 
  def write(self, oprot):
17175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17177 
      return
17178 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17179 
    oprot.writeFieldStop()
17180 
    oprot.writeStructEnd()
17181 
 
17182 
  def validate(self):
17183 
    return
17184 
 
17185 
 
17186 
  def __repr__(self):
17187 
    L = ['%s=%r' % (key, value)
17188 
      for key, value in self.__dict__.iteritems()]
17189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17190 
 
17191 
  def __eq__(self, other):
17192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17193 
 
17194 
  def __ne__(self, other):
17195 
    return not (self == other)
17196 
 
17197 
class getSlippedSippingDateOrders_result:
17198 
  """
17199 
  Attributes:
17200 
   - success
17201 
   - ex
17202 
  """
17203 
 
17204 
  thrift_spec = (
17205 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17207 
  )
17208 
 
17209 
  def __init__(self, success=None, ex=None,):
17210 
    self.success = success
17211 
    self.ex = ex
17212 
 
17213 
  def read(self, iprot):
17214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17216 
      return
17217 
    iprot.readStructBegin()
17218 
    while True:
17219 
      (fname, ftype, fid) = iprot.readFieldBegin()
17220 
      if ftype == TType.STOP:
17221 
        break
17222 
      if fid == 0:
17223 
        if ftype == TType.LIST:
17224 
          self.success = []
17225 
          (_etype301, _size298) = iprot.readListBegin()
17226 
          for _i302 in xrange(_size298):
17227 
            _elem303 = Order()
17228 
            _elem303.read(iprot)
17229 
            self.success.append(_elem303)
17230 
          iprot.readListEnd()
17231 
        else:
17232 
          iprot.skip(ftype)
17233 
      elif fid == 1:
17234 
        if ftype == TType.STRUCT:
17235 
          self.ex = TransactionServiceException()
17236 
          self.ex.read(iprot)
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('getSlippedSippingDateOrders_result')
17249 
    if self.success is not None:
17250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17252 
      for iter304 in self.success:
17253 
        iter304.write(oprot)
17254 
      oprot.writeListEnd()
17255 
      oprot.writeFieldEnd()
17256 
    if self.ex is not None:
17257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17258 
      self.ex.write(oprot)
17259 
      oprot.writeFieldEnd()
17260 
    oprot.writeFieldStop()
17261 
    oprot.writeStructEnd()
17262 
 
17263 
  def validate(self):
17264 
    return
17265 
 
17266 
 
17267 
  def __repr__(self):
17268 
    L = ['%s=%r' % (key, value)
17269 
      for key, value in self.__dict__.iteritems()]
17270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17271 
 
17272 
  def __eq__(self, other):
17273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17274 
 
17275 
  def __ne__(self, other):
17276 
    return not (self == other)
17277 
 
4600 varun.gupt 17278 
class saveBluedartSettlements_args:
17279 
  """
17280 
  Attributes:
17281 
   - mapAWBAndAmount
17282 
  """
17283 
 
17284 
  thrift_spec = (
17285 
    None, # 0
17286 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17287 
  )
17288 
 
17289 
  def __init__(self, mapAWBAndAmount=None,):
17290 
    self.mapAWBAndAmount = mapAWBAndAmount
17291 
 
17292 
  def read(self, iprot):
17293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17295 
      return
17296 
    iprot.readStructBegin()
17297 
    while True:
17298 
      (fname, ftype, fid) = iprot.readFieldBegin()
17299 
      if ftype == TType.STOP:
17300 
        break
17301 
      if fid == 1:
17302 
        if ftype == TType.MAP:
17303 
          self.mapAWBAndAmount = {}
4607 rajveer 17304 
          (_ktype306, _vtype307, _size305 ) = iprot.readMapBegin()
17305 
          for _i309 in xrange(_size305):
17306 
            _key310 = iprot.readI64();
17307 
            _val311 = iprot.readDouble();
17308 
            self.mapAWBAndAmount[_key310] = _val311
4600 varun.gupt 17309 
          iprot.readMapEnd()
17310 
        else:
17311 
          iprot.skip(ftype)
17312 
      else:
17313 
        iprot.skip(ftype)
17314 
      iprot.readFieldEnd()
17315 
    iprot.readStructEnd()
17316 
 
17317 
  def write(self, oprot):
17318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17320 
      return
17321 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17322 
    if self.mapAWBAndAmount is not None:
17323 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17324 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4607 rajveer 17325 
      for kiter312,viter313 in self.mapAWBAndAmount.items():
17326 
        oprot.writeI64(kiter312)
17327 
        oprot.writeDouble(viter313)
4600 varun.gupt 17328 
      oprot.writeMapEnd()
17329 
      oprot.writeFieldEnd()
17330 
    oprot.writeFieldStop()
17331 
    oprot.writeStructEnd()
17332 
 
17333 
  def validate(self):
17334 
    return
17335 
 
17336 
 
17337 
  def __repr__(self):
17338 
    L = ['%s=%r' % (key, value)
17339 
      for key, value in self.__dict__.iteritems()]
17340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17341 
 
17342 
  def __eq__(self, other):
17343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17344 
 
17345 
  def __ne__(self, other):
17346 
    return not (self == other)
17347 
 
17348 
class saveBluedartSettlements_result:
17349 
  """
17350 
  Attributes:
17351 
   - ex
17352 
  """
17353 
 
17354 
  thrift_spec = (
17355 
    None, # 0
17356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17357 
  )
17358 
 
17359 
  def __init__(self, ex=None,):
17360 
    self.ex = ex
17361 
 
17362 
  def read(self, iprot):
17363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17365 
      return
17366 
    iprot.readStructBegin()
17367 
    while True:
17368 
      (fname, ftype, fid) = iprot.readFieldBegin()
17369 
      if ftype == TType.STOP:
17370 
        break
17371 
      if fid == 1:
17372 
        if ftype == TType.STRUCT:
17373 
          self.ex = TransactionServiceException()
17374 
          self.ex.read(iprot)
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      else:
17378 
        iprot.skip(ftype)
17379 
      iprot.readFieldEnd()
17380 
    iprot.readStructEnd()
17381 
 
17382 
  def write(self, oprot):
17383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17385 
      return
17386 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17387 
    if self.ex is not None:
17388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17389 
      self.ex.write(oprot)
17390 
      oprot.writeFieldEnd()
17391 
    oprot.writeFieldStop()
17392 
    oprot.writeStructEnd()
17393 
 
17394 
  def validate(self):
17395 
    return
17396 
 
17397 
 
17398 
  def __repr__(self):
17399 
    L = ['%s=%r' % (key, value)
17400 
      for key, value in self.__dict__.iteritems()]
17401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17402 
 
17403 
  def __eq__(self, other):
17404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17405 
 
17406 
  def __ne__(self, other):
17407 
    return not (self == other)
17408 
 
17409 
class savePaymentSettlements_args:
17410 
  """
17411 
  Attributes:
17412 
   - settlementDate
17413 
   - paymentGatewayId
17414 
   - paymentId
17415 
   - serviceTax
17416 
   - otherCharges
17417 
   - netCollection
17418 
  """
17419 
 
17420 
  thrift_spec = (
17421 
    None, # 0
17422 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17423 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17424 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17425 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17426 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17427 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17428 
  )
17429 
 
17430 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17431 
    self.settlementDate = settlementDate
17432 
    self.paymentGatewayId = paymentGatewayId
17433 
    self.paymentId = paymentId
17434 
    self.serviceTax = serviceTax
17435 
    self.otherCharges = otherCharges
17436 
    self.netCollection = netCollection
17437 
 
17438 
  def read(self, iprot):
17439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17441 
      return
17442 
    iprot.readStructBegin()
17443 
    while True:
17444 
      (fname, ftype, fid) = iprot.readFieldBegin()
17445 
      if ftype == TType.STOP:
17446 
        break
17447 
      if fid == 1:
17448 
        if ftype == TType.I64:
17449 
          self.settlementDate = iprot.readI64();
17450 
        else:
17451 
          iprot.skip(ftype)
17452 
      elif fid == 2:
17453 
        if ftype == TType.I64:
17454 
          self.paymentGatewayId = iprot.readI64();
17455 
        else:
17456 
          iprot.skip(ftype)
17457 
      elif fid == 3:
17458 
        if ftype == TType.I64:
17459 
          self.paymentId = iprot.readI64();
17460 
        else:
17461 
          iprot.skip(ftype)
17462 
      elif fid == 4:
17463 
        if ftype == TType.DOUBLE:
17464 
          self.serviceTax = iprot.readDouble();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      elif fid == 5:
17468 
        if ftype == TType.DOUBLE:
17469 
          self.otherCharges = iprot.readDouble();
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 6:
17473 
        if ftype == TType.DOUBLE:
17474 
          self.netCollection = iprot.readDouble();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      else:
17478 
        iprot.skip(ftype)
17479 
      iprot.readFieldEnd()
17480 
    iprot.readStructEnd()
17481 
 
17482 
  def write(self, oprot):
17483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17485 
      return
17486 
    oprot.writeStructBegin('savePaymentSettlements_args')
17487 
    if self.settlementDate is not None:
17488 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17489 
      oprot.writeI64(self.settlementDate)
17490 
      oprot.writeFieldEnd()
17491 
    if self.paymentGatewayId is not None:
17492 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17493 
      oprot.writeI64(self.paymentGatewayId)
17494 
      oprot.writeFieldEnd()
17495 
    if self.paymentId is not None:
17496 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17497 
      oprot.writeI64(self.paymentId)
17498 
      oprot.writeFieldEnd()
17499 
    if self.serviceTax is not None:
17500 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17501 
      oprot.writeDouble(self.serviceTax)
17502 
      oprot.writeFieldEnd()
17503 
    if self.otherCharges is not None:
17504 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17505 
      oprot.writeDouble(self.otherCharges)
17506 
      oprot.writeFieldEnd()
17507 
    if self.netCollection is not None:
17508 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17509 
      oprot.writeDouble(self.netCollection)
17510 
      oprot.writeFieldEnd()
17511 
    oprot.writeFieldStop()
17512 
    oprot.writeStructEnd()
17513 
 
17514 
  def validate(self):
17515 
    return
17516 
 
17517 
 
17518 
  def __repr__(self):
17519 
    L = ['%s=%r' % (key, value)
17520 
      for key, value in self.__dict__.iteritems()]
17521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17522 
 
17523 
  def __eq__(self, other):
17524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17525 
 
17526 
  def __ne__(self, other):
17527 
    return not (self == other)
17528 
 
17529 
class savePaymentSettlements_result:
17530 
  """
17531 
  Attributes:
17532 
   - ex
17533 
  """
17534 
 
17535 
  thrift_spec = (
17536 
    None, # 0
17537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17538 
  )
17539 
 
17540 
  def __init__(self, ex=None,):
17541 
    self.ex = ex
17542 
 
17543 
  def read(self, iprot):
17544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17546 
      return
17547 
    iprot.readStructBegin()
17548 
    while True:
17549 
      (fname, ftype, fid) = iprot.readFieldBegin()
17550 
      if ftype == TType.STOP:
17551 
        break
17552 
      if fid == 1:
17553 
        if ftype == TType.STRUCT:
17554 
          self.ex = TransactionServiceException()
17555 
          self.ex.read(iprot)
17556 
        else:
17557 
          iprot.skip(ftype)
17558 
      else:
17559 
        iprot.skip(ftype)
17560 
      iprot.readFieldEnd()
17561 
    iprot.readStructEnd()
17562 
 
17563 
  def write(self, oprot):
17564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17566 
      return
17567 
    oprot.writeStructBegin('savePaymentSettlements_result')
17568 
    if self.ex is not None:
17569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17570 
      self.ex.write(oprot)
17571 
      oprot.writeFieldEnd()
17572 
    oprot.writeFieldStop()
17573 
    oprot.writeStructEnd()
17574 
 
17575 
  def validate(self):
17576 
    return
17577 
 
17578 
 
17579 
  def __repr__(self):
17580 
    L = ['%s=%r' % (key, value)
17581 
      for key, value in self.__dict__.iteritems()]
17582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17583 
 
17584 
  def __eq__(self, other):
17585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17586 
 
17587 
  def __ne__(self, other):
17588 
    return not (self == other)
17589 
 
17590 
class saveEBSSettlementSummary_args:
17591 
  """
17592 
  Attributes:
17593 
   - settlementId
17594 
   - settlementDate
17595 
   - transactionDateFrom
17596 
   - transactionDateTo
17597 
   - amount
17598 
  """
17599 
 
17600 
  thrift_spec = (
17601 
    None, # 0
17602 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17603 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
17604 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
17605 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
17606 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
17607 
  )
17608 
 
17609 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
17610 
    self.settlementId = settlementId
17611 
    self.settlementDate = settlementDate
17612 
    self.transactionDateFrom = transactionDateFrom
17613 
    self.transactionDateTo = transactionDateTo
17614 
    self.amount = amount
17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 1:
17626 
        if ftype == TType.I64:
17627 
          self.settlementId = iprot.readI64();
17628 
        else:
17629 
          iprot.skip(ftype)
17630 
      elif fid == 2:
17631 
        if ftype == TType.I64:
17632 
          self.settlementDate = iprot.readI64();
17633 
        else:
17634 
          iprot.skip(ftype)
17635 
      elif fid == 3:
17636 
        if ftype == TType.I64:
17637 
          self.transactionDateFrom = iprot.readI64();
17638 
        else:
17639 
          iprot.skip(ftype)
17640 
      elif fid == 4:
17641 
        if ftype == TType.I64:
17642 
          self.transactionDateTo = iprot.readI64();
17643 
        else:
17644 
          iprot.skip(ftype)
17645 
      elif fid == 5:
17646 
        if ftype == TType.DOUBLE:
17647 
          self.amount = iprot.readDouble();
17648 
        else:
17649 
          iprot.skip(ftype)
17650 
      else:
17651 
        iprot.skip(ftype)
17652 
      iprot.readFieldEnd()
17653 
    iprot.readStructEnd()
17654 
 
17655 
  def write(self, oprot):
17656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17658 
      return
17659 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
17660 
    if self.settlementId is not None:
17661 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17662 
      oprot.writeI64(self.settlementId)
17663 
      oprot.writeFieldEnd()
17664 
    if self.settlementDate is not None:
17665 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
17666 
      oprot.writeI64(self.settlementDate)
17667 
      oprot.writeFieldEnd()
17668 
    if self.transactionDateFrom is not None:
17669 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
17670 
      oprot.writeI64(self.transactionDateFrom)
17671 
      oprot.writeFieldEnd()
17672 
    if self.transactionDateTo is not None:
17673 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
17674 
      oprot.writeI64(self.transactionDateTo)
17675 
      oprot.writeFieldEnd()
17676 
    if self.amount is not None:
17677 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
17678 
      oprot.writeDouble(self.amount)
17679 
      oprot.writeFieldEnd()
17680 
    oprot.writeFieldStop()
17681 
    oprot.writeStructEnd()
17682 
 
17683 
  def validate(self):
17684 
    return
17685 
 
17686 
 
17687 
  def __repr__(self):
17688 
    L = ['%s=%r' % (key, value)
17689 
      for key, value in self.__dict__.iteritems()]
17690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17691 
 
17692 
  def __eq__(self, other):
17693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17694 
 
17695 
  def __ne__(self, other):
17696 
    return not (self == other)
17697 
 
17698 
class saveEBSSettlementSummary_result:
17699 
  """
17700 
  Attributes:
17701 
   - ex
17702 
  """
17703 
 
17704 
  thrift_spec = (
17705 
    None, # 0
17706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17707 
  )
17708 
 
17709 
  def __init__(self, ex=None,):
17710 
    self.ex = ex
17711 
 
17712 
  def read(self, iprot):
17713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17715 
      return
17716 
    iprot.readStructBegin()
17717 
    while True:
17718 
      (fname, ftype, fid) = iprot.readFieldBegin()
17719 
      if ftype == TType.STOP:
17720 
        break
17721 
      if fid == 1:
17722 
        if ftype == TType.STRUCT:
17723 
          self.ex = TransactionServiceException()
17724 
          self.ex.read(iprot)
17725 
        else:
17726 
          iprot.skip(ftype)
17727 
      else:
17728 
        iprot.skip(ftype)
17729 
      iprot.readFieldEnd()
17730 
    iprot.readStructEnd()
17731 
 
17732 
  def write(self, oprot):
17733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17735 
      return
17736 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
17737 
    if self.ex is not None:
17738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17739 
      self.ex.write(oprot)
17740 
      oprot.writeFieldEnd()
17741 
    oprot.writeFieldStop()
17742 
    oprot.writeStructEnd()
17743 
 
17744 
  def validate(self):
17745 
    return
17746 
 
17747 
 
17748 
  def __repr__(self):
17749 
    L = ['%s=%r' % (key, value)
17750 
      for key, value in self.__dict__.iteritems()]
17751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17752 
 
17753 
  def __eq__(self, other):
17754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17755 
 
17756 
  def __ne__(self, other):
17757 
    return not (self == other)
17758 
 
17759 
class getSettlementForPaymentId_args:
17760 
  """
17761 
  Attributes:
17762 
   - paymentId
17763 
  """
17764 
 
17765 
  thrift_spec = (
17766 
    None, # 0
17767 
    (1, TType.I64, 'paymentId', None, None, ), # 1
17768 
  )
17769 
 
17770 
  def __init__(self, paymentId=None,):
17771 
    self.paymentId = paymentId
17772 
 
17773 
  def read(self, iprot):
17774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17776 
      return
17777 
    iprot.readStructBegin()
17778 
    while True:
17779 
      (fname, ftype, fid) = iprot.readFieldBegin()
17780 
      if ftype == TType.STOP:
17781 
        break
17782 
      if fid == 1:
17783 
        if ftype == TType.I64:
17784 
          self.paymentId = iprot.readI64();
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      else:
17788 
        iprot.skip(ftype)
17789 
      iprot.readFieldEnd()
17790 
    iprot.readStructEnd()
17791 
 
17792 
  def write(self, oprot):
17793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17795 
      return
17796 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
17797 
    if self.paymentId is not None:
17798 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
17799 
      oprot.writeI64(self.paymentId)
17800 
      oprot.writeFieldEnd()
17801 
    oprot.writeFieldStop()
17802 
    oprot.writeStructEnd()
17803 
 
17804 
  def validate(self):
17805 
    return
17806 
 
17807 
 
17808 
  def __repr__(self):
17809 
    L = ['%s=%r' % (key, value)
17810 
      for key, value in self.__dict__.iteritems()]
17811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17812 
 
17813 
  def __eq__(self, other):
17814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17815 
 
17816 
  def __ne__(self, other):
17817 
    return not (self == other)
17818 
 
17819 
class getSettlementForPaymentId_result:
17820 
  """
17821 
  Attributes:
17822 
   - success
17823 
   - ex
17824 
  """
17825 
 
17826 
  thrift_spec = (
17827 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
17828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17829 
  )
17830 
 
17831 
  def __init__(self, success=None, ex=None,):
17832 
    self.success = success
17833 
    self.ex = ex
17834 
 
17835 
  def read(self, iprot):
17836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17838 
      return
17839 
    iprot.readStructBegin()
17840 
    while True:
17841 
      (fname, ftype, fid) = iprot.readFieldBegin()
17842 
      if ftype == TType.STOP:
17843 
        break
17844 
      if fid == 0:
17845 
        if ftype == TType.STRUCT:
17846 
          self.success = PaymentSettlement()
17847 
          self.success.read(iprot)
17848 
        else:
17849 
          iprot.skip(ftype)
17850 
      elif fid == 1:
17851 
        if ftype == TType.STRUCT:
17852 
          self.ex = TransactionServiceException()
17853 
          self.ex.read(iprot)
17854 
        else:
17855 
          iprot.skip(ftype)
17856 
      else:
17857 
        iprot.skip(ftype)
17858 
      iprot.readFieldEnd()
17859 
    iprot.readStructEnd()
17860 
 
17861 
  def write(self, oprot):
17862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17864 
      return
17865 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
17866 
    if self.success is not None:
17867 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17868 
      self.success.write(oprot)
17869 
      oprot.writeFieldEnd()
17870 
    if self.ex is not None:
17871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17872 
      self.ex.write(oprot)
17873 
      oprot.writeFieldEnd()
17874 
    oprot.writeFieldStop()
17875 
    oprot.writeStructEnd()
17876 
 
17877 
  def validate(self):
17878 
    return
17879 
 
17880 
 
17881 
  def __repr__(self):
17882 
    L = ['%s=%r' % (key, value)
17883 
      for key, value in self.__dict__.iteritems()]
17884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17885 
 
17886 
  def __eq__(self, other):
17887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17888 
 
17889 
  def __ne__(self, other):
17890 
    return not (self == other)
17891 
 
17892 
class getEBSSettlementSummaries_args:
17893 
 
17894 
  thrift_spec = (
17895 
  )
17896 
 
17897 
  def read(self, iprot):
17898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17900 
      return
17901 
    iprot.readStructBegin()
17902 
    while True:
17903 
      (fname, ftype, fid) = iprot.readFieldBegin()
17904 
      if ftype == TType.STOP:
17905 
        break
17906 
      else:
17907 
        iprot.skip(ftype)
17908 
      iprot.readFieldEnd()
17909 
    iprot.readStructEnd()
17910 
 
17911 
  def write(self, oprot):
17912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17914 
      return
17915 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
17916 
    oprot.writeFieldStop()
17917 
    oprot.writeStructEnd()
17918 
 
17919 
  def validate(self):
17920 
    return
17921 
 
17922 
 
17923 
  def __repr__(self):
17924 
    L = ['%s=%r' % (key, value)
17925 
      for key, value in self.__dict__.iteritems()]
17926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17927 
 
17928 
  def __eq__(self, other):
17929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17930 
 
17931 
  def __ne__(self, other):
17932 
    return not (self == other)
17933 
 
17934 
class getEBSSettlementSummaries_result:
17935 
  """
17936 
  Attributes:
17937 
   - success
17938 
   - ex
17939 
  """
17940 
 
17941 
  thrift_spec = (
17942 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
17943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17944 
  )
17945 
 
17946 
  def __init__(self, success=None, ex=None,):
17947 
    self.success = success
17948 
    self.ex = ex
17949 
 
17950 
  def read(self, iprot):
17951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17953 
      return
17954 
    iprot.readStructBegin()
17955 
    while True:
17956 
      (fname, ftype, fid) = iprot.readFieldBegin()
17957 
      if ftype == TType.STOP:
17958 
        break
17959 
      if fid == 0:
17960 
        if ftype == TType.MAP:
17961 
          self.success = {}
4607 rajveer 17962 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
17963 
          for _i318 in xrange(_size314):
17964 
            _key319 = iprot.readI64();
17965 
            _val320 = iprot.readString();
17966 
            self.success[_key319] = _val320
4600 varun.gupt 17967 
          iprot.readMapEnd()
17968 
        else:
17969 
          iprot.skip(ftype)
17970 
      elif fid == 1:
17971 
        if ftype == TType.STRUCT:
17972 
          self.ex = TransactionServiceException()
17973 
          self.ex.read(iprot)
17974 
        else:
17975 
          iprot.skip(ftype)
17976 
      else:
17977 
        iprot.skip(ftype)
17978 
      iprot.readFieldEnd()
17979 
    iprot.readStructEnd()
17980 
 
17981 
  def write(self, oprot):
17982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17984 
      return
17985 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
17986 
    if self.success is not None:
17987 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17988 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4607 rajveer 17989 
      for kiter321,viter322 in self.success.items():
17990 
        oprot.writeI64(kiter321)
17991 
        oprot.writeString(viter322)
4600 varun.gupt 17992 
      oprot.writeMapEnd()
17993 
      oprot.writeFieldEnd()
17994 
    if self.ex is not None:
17995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17996 
      self.ex.write(oprot)
17997 
      oprot.writeFieldEnd()
17998 
    oprot.writeFieldStop()
17999 
    oprot.writeStructEnd()
18000 
 
18001 
  def validate(self):
18002 
    return
18003 
 
18004 
 
18005 
  def __repr__(self):
18006 
    L = ['%s=%r' % (key, value)
18007 
      for key, value in self.__dict__.iteritems()]
18008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18009 
 
18010 
  def __eq__(self, other):
18011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18012 
 
18013 
  def __ne__(self, other):
18014 
    return not (self == other)
18015 
 
18016 
class markEBSSettlementUploaded_args:
18017 
  """
18018 
  Attributes:
18019 
   - settlementId
18020 
  """
18021 
 
18022 
  thrift_spec = (
18023 
    None, # 0
18024 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18025 
  )
18026 
 
18027 
  def __init__(self, settlementId=None,):
18028 
    self.settlementId = settlementId
18029 
 
18030 
  def read(self, iprot):
18031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18033 
      return
18034 
    iprot.readStructBegin()
18035 
    while True:
18036 
      (fname, ftype, fid) = iprot.readFieldBegin()
18037 
      if ftype == TType.STOP:
18038 
        break
18039 
      if fid == 1:
18040 
        if ftype == TType.I64:
18041 
          self.settlementId = iprot.readI64();
18042 
        else:
18043 
          iprot.skip(ftype)
18044 
      else:
18045 
        iprot.skip(ftype)
18046 
      iprot.readFieldEnd()
18047 
    iprot.readStructEnd()
18048 
 
18049 
  def write(self, oprot):
18050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18052 
      return
18053 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18054 
    if self.settlementId is not None:
18055 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18056 
      oprot.writeI64(self.settlementId)
18057 
      oprot.writeFieldEnd()
18058 
    oprot.writeFieldStop()
18059 
    oprot.writeStructEnd()
18060 
 
18061 
  def validate(self):
18062 
    return
18063 
 
18064 
 
18065 
  def __repr__(self):
18066 
    L = ['%s=%r' % (key, value)
18067 
      for key, value in self.__dict__.iteritems()]
18068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18069 
 
18070 
  def __eq__(self, other):
18071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18072 
 
18073 
  def __ne__(self, other):
18074 
    return not (self == other)
18075 
 
18076 
class markEBSSettlementUploaded_result:
18077 
  """
18078 
  Attributes:
18079 
   - ex
18080 
  """
18081 
 
18082 
  thrift_spec = (
18083 
    None, # 0
18084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18085 
  )
18086 
 
18087 
  def __init__(self, ex=None,):
18088 
    self.ex = ex
18089 
 
18090 
  def read(self, iprot):
18091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18093 
      return
18094 
    iprot.readStructBegin()
18095 
    while True:
18096 
      (fname, ftype, fid) = iprot.readFieldBegin()
18097 
      if ftype == TType.STOP:
18098 
        break
18099 
      if fid == 1:
18100 
        if ftype == TType.STRUCT:
18101 
          self.ex = TransactionServiceException()
18102 
          self.ex.read(iprot)
18103 
        else:
18104 
          iprot.skip(ftype)
18105 
      else:
18106 
        iprot.skip(ftype)
18107 
      iprot.readFieldEnd()
18108 
    iprot.readStructEnd()
18109 
 
18110 
  def write(self, oprot):
18111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18113 
      return
18114 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18115 
    if self.ex is not None:
18116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18117 
      self.ex.write(oprot)
18118 
      oprot.writeFieldEnd()
18119 
    oprot.writeFieldStop()
18120 
    oprot.writeStructEnd()
18121 
 
18122 
  def validate(self):
18123 
    return
18124 
 
18125 
 
18126 
  def __repr__(self):
18127 
    L = ['%s=%r' % (key, value)
18128 
      for key, value in self.__dict__.iteritems()]
18129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18130 
 
18131 
  def __eq__(self, other):
18132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18133 
 
18134 
  def __ne__(self, other):
18135 
    return not (self == other)
18136 
 
18137 
class getEBSSettlementDate_args:
18138 
  """
18139 
  Attributes:
18140 
   - settlementId
18141 
  """
18142 
 
18143 
  thrift_spec = (
18144 
    None, # 0
18145 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18146 
  )
18147 
 
18148 
  def __init__(self, settlementId=None,):
18149 
    self.settlementId = settlementId
18150 
 
18151 
  def read(self, iprot):
18152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18154 
      return
18155 
    iprot.readStructBegin()
18156 
    while True:
18157 
      (fname, ftype, fid) = iprot.readFieldBegin()
18158 
      if ftype == TType.STOP:
18159 
        break
18160 
      if fid == 1:
18161 
        if ftype == TType.I64:
18162 
          self.settlementId = iprot.readI64();
18163 
        else:
18164 
          iprot.skip(ftype)
18165 
      else:
18166 
        iprot.skip(ftype)
18167 
      iprot.readFieldEnd()
18168 
    iprot.readStructEnd()
18169 
 
18170 
  def write(self, oprot):
18171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18173 
      return
18174 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18175 
    if self.settlementId is not None:
18176 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18177 
      oprot.writeI64(self.settlementId)
18178 
      oprot.writeFieldEnd()
18179 
    oprot.writeFieldStop()
18180 
    oprot.writeStructEnd()
18181 
 
18182 
  def validate(self):
18183 
    return
18184 
 
18185 
 
18186 
  def __repr__(self):
18187 
    L = ['%s=%r' % (key, value)
18188 
      for key, value in self.__dict__.iteritems()]
18189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18190 
 
18191 
  def __eq__(self, other):
18192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18193 
 
18194 
  def __ne__(self, other):
18195 
    return not (self == other)
18196 
 
18197 
class getEBSSettlementDate_result:
18198 
  """
18199 
  Attributes:
18200 
   - success
18201 
   - ex
18202 
  """
18203 
 
18204 
  thrift_spec = (
18205 
    (0, TType.I64, 'success', None, None, ), # 0
18206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18207 
  )
18208 
 
18209 
  def __init__(self, success=None, ex=None,):
18210 
    self.success = success
18211 
    self.ex = ex
18212 
 
18213 
  def read(self, iprot):
18214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18216 
      return
18217 
    iprot.readStructBegin()
18218 
    while True:
18219 
      (fname, ftype, fid) = iprot.readFieldBegin()
18220 
      if ftype == TType.STOP:
18221 
        break
18222 
      if fid == 0:
18223 
        if ftype == TType.I64:
18224 
          self.success = iprot.readI64();
18225 
        else:
18226 
          iprot.skip(ftype)
18227 
      elif fid == 1:
18228 
        if ftype == TType.STRUCT:
18229 
          self.ex = TransactionServiceException()
18230 
          self.ex.read(iprot)
18231 
        else:
18232 
          iprot.skip(ftype)
18233 
      else:
18234 
        iprot.skip(ftype)
18235 
      iprot.readFieldEnd()
18236 
    iprot.readStructEnd()
18237 
 
18238 
  def write(self, oprot):
18239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18241 
      return
18242 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18243 
    if self.success is not None:
18244 
      oprot.writeFieldBegin('success', TType.I64, 0)
18245 
      oprot.writeI64(self.success)
18246 
      oprot.writeFieldEnd()
18247 
    if self.ex is not None:
18248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18249 
      self.ex.write(oprot)
18250 
      oprot.writeFieldEnd()
18251 
    oprot.writeFieldStop()
18252 
    oprot.writeStructEnd()
18253 
 
18254 
  def validate(self):
18255 
    return
18256 
 
18257 
 
18258 
  def __repr__(self):
18259 
    L = ['%s=%r' % (key, value)
18260 
      for key, value in self.__dict__.iteritems()]
18261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18262 
 
18263 
  def __eq__(self, other):
18264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18265 
 
18266 
  def __ne__(self, other):
18267 
    return not (self == other)