Subversion Repositories SmartDukaan

Rev

Rev 4600 | Rev 4607 | 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 
 
900 
  def saveBluedartSettlements(self, mapAWBAndAmount):
901 
    """
902 
    Parameters:
903 
     - mapAWBAndAmount
904 
    """
905 
    pass
906 
 
907 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
908 
    """
909 
    Parameters:
910 
     - settlementDate
911 
     - paymentGatewayId
912 
     - paymentId
913 
     - serviceTax
914 
     - otherCharges
915 
     - netCollection
916 
    """
917 
    pass
918 
 
919 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
920 
    """
921 
    Parameters:
922 
     - settlementId
923 
     - settlementDate
924 
     - transactionDateFrom
925 
     - transactionDateTo
926 
     - amount
927 
    """
928 
    pass
929 
 
930 
  def getSettlementForPaymentId(self, paymentId):
931 
    """
932 
    Parameters:
933 
     - paymentId
934 
    """
935 
    pass
936 
 
937 
  def getEBSSettlementSummaries(self, ):
938 
    pass
939 
 
940 
  def markEBSSettlementUploaded(self, settlementId):
941 
    """
942 
    Parameters:
943 
     - settlementId
944 
    """
945 
    pass
946 
 
947 
  def getEBSSettlementDate(self, settlementId):
948 
    """
949 
    Parameters:
950 
     - settlementId
951 
    """
952 
    pass
953 
 
954 
 
3376 rajveer 955 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 956 
  def __init__(self, iprot, oprot=None):
3376 rajveer 957 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 958 
 
959 
  def createTransaction(self, transaction):
960 
    """
961 
    Parameters:
962 
     - transaction
963 
    """
964 
    self.send_createTransaction(transaction)
132 ashish 965 
    return self.recv_createTransaction()
94 ashish 966 
 
967 
  def send_createTransaction(self, transaction):
968 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
969 
    args = createTransaction_args()
970 
    args.transaction = transaction
971 
    args.write(self._oprot)
972 
    self._oprot.writeMessageEnd()
973 
    self._oprot.trans.flush()
974 
 
975 
  def recv_createTransaction(self, ):
976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
977 
    if mtype == TMessageType.EXCEPTION:
978 
      x = TApplicationException()
979 
      x.read(self._iprot)
980 
      self._iprot.readMessageEnd()
981 
      raise x
982 
    result = createTransaction_result()
983 
    result.read(self._iprot)
984 
    self._iprot.readMessageEnd()
3431 rajveer 985 
    if result.success is not None:
132 ashish 986 
      return result.success
3431 rajveer 987 
    if result.ex is not None:
94 ashish 988 
      raise result.ex
132 ashish 989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 990 
 
991 
  def getTransaction(self, id):
992 
    """
993 
    Parameters:
994 
     - id
995 
    """
996 
    self.send_getTransaction(id)
997 
    return self.recv_getTransaction()
998 
 
999 
  def send_getTransaction(self, id):
1000 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1001 
    args = getTransaction_args()
1002 
    args.id = id
1003 
    args.write(self._oprot)
1004 
    self._oprot.writeMessageEnd()
1005 
    self._oprot.trans.flush()
1006 
 
1007 
  def recv_getTransaction(self, ):
1008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1009 
    if mtype == TMessageType.EXCEPTION:
1010 
      x = TApplicationException()
1011 
      x.read(self._iprot)
1012 
      self._iprot.readMessageEnd()
1013 
      raise x
1014 
    result = getTransaction_result()
1015 
    result.read(self._iprot)
1016 
    self._iprot.readMessageEnd()
3431 rajveer 1017 
    if result.success is not None:
94 ashish 1018 
      return result.success
3431 rajveer 1019 
    if result.ex is not None:
94 ashish 1020 
      raise result.ex
1021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1022 
 
1023 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1024 
    """
1025 
    Parameters:
1026 
     - customerId
1027 
     - from_date
1028 
     - to_date
1029 
     - status
1030 
    """
1031 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1032 
    return self.recv_getTransactionsForCustomer()
1033 
 
1034 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1035 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1036 
    args = getTransactionsForCustomer_args()
1037 
    args.customerId = customerId
1038 
    args.from_date = from_date
1039 
    args.to_date = to_date
1040 
    args.status = status
1041 
    args.write(self._oprot)
1042 
    self._oprot.writeMessageEnd()
1043 
    self._oprot.trans.flush()
1044 
 
1045 
  def recv_getTransactionsForCustomer(self, ):
1046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1047 
    if mtype == TMessageType.EXCEPTION:
1048 
      x = TApplicationException()
1049 
      x.read(self._iprot)
1050 
      self._iprot.readMessageEnd()
1051 
      raise x
1052 
    result = getTransactionsForCustomer_result()
1053 
    result.read(self._iprot)
1054 
    self._iprot.readMessageEnd()
3431 rajveer 1055 
    if result.success is not None:
94 ashish 1056 
      return result.success
3431 rajveer 1057 
    if result.ex is not None:
94 ashish 1058 
      raise result.ex
1059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1060 
 
132 ashish 1061 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1062 
    """
1063 
    Parameters:
1064 
     - shoppingCartId
1065 
    """
1066 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1067 
    return self.recv_getTransactionsForShoppingCartId()
1068 
 
1069 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1070 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1071 
    args = getTransactionsForShoppingCartId_args()
1072 
    args.shoppingCartId = shoppingCartId
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_getTransactionsForShoppingCartId(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = getTransactionsForShoppingCartId_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
3431 rajveer 1087 
    if result.success is not None:
132 ashish 1088 
      return result.success
3431 rajveer 1089 
    if result.ex is not None:
132 ashish 1090 
      raise result.ex
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1092 
 
94 ashish 1093 
  def getTransactionStatus(self, transactionId):
1094 
    """
1095 
    Parameters:
1096 
     - transactionId
1097 
    """
1098 
    self.send_getTransactionStatus(transactionId)
1099 
    return self.recv_getTransactionStatus()
1100 
 
1101 
  def send_getTransactionStatus(self, transactionId):
1102 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1103 
    args = getTransactionStatus_args()
1104 
    args.transactionId = transactionId
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1109 
  def recv_getTransactionStatus(self, ):
1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1116 
    result = getTransactionStatus_result()
1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
3431 rajveer 1119 
    if result.success is not None:
94 ashish 1120 
      return result.success
3431 rajveer 1121 
    if result.ex is not None:
94 ashish 1122 
      raise result.ex
1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1124 
 
1125 
  def changeTransactionStatus(self, transactionId, status, description):
1126 
    """
1127 
    Parameters:
1128 
     - transactionId
1129 
     - status
1130 
     - description
1131 
    """
1132 
    self.send_changeTransactionStatus(transactionId, status, description)
1133 
    return self.recv_changeTransactionStatus()
1134 
 
1135 
  def send_changeTransactionStatus(self, transactionId, status, description):
1136 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1137 
    args = changeTransactionStatus_args()
1138 
    args.transactionId = transactionId
1139 
    args.status = status
1140 
    args.description = description
1141 
    args.write(self._oprot)
1142 
    self._oprot.writeMessageEnd()
1143 
    self._oprot.trans.flush()
1144 
 
1145 
  def recv_changeTransactionStatus(self, ):
1146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1147 
    if mtype == TMessageType.EXCEPTION:
1148 
      x = TApplicationException()
1149 
      x.read(self._iprot)
1150 
      self._iprot.readMessageEnd()
1151 
      raise x
1152 
    result = changeTransactionStatus_result()
1153 
    result.read(self._iprot)
1154 
    self._iprot.readMessageEnd()
3431 rajveer 1155 
    if result.success is not None:
94 ashish 1156 
      return result.success
3431 rajveer 1157 
    if result.ex is not None:
94 ashish 1158 
      raise result.ex
1159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1160 
 
1398 varun.gupt 1161 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1162 
    """
1163 
    Parameters:
1164 
     - transactionId
1165 
    """
1398 varun.gupt 1166 
    self.send_enqueueTransactionInfoEmail(transactionId)
1167 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1168 
 
1398 varun.gupt 1169 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1170 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1171 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1172 
    args.transactionId = transactionId
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1398 varun.gupt 1177 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1398 varun.gupt 1184 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
3431 rajveer 1187 
    if result.success is not None:
1382 varun.gupt 1188 
      return result.success
3431 rajveer 1189 
    if result.ex is not None:
1382 varun.gupt 1190 
      raise result.ex
1398 varun.gupt 1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1192 
 
483 rajveer 1193 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1194 
    """
1195 
    Parameters:
483 rajveer 1196 
     - status
1197 
     - from_date
1198 
     - to_date
1199 
     - warehouse_id
94 ashish 1200 
    """
483 rajveer 1201 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1202 
    return self.recv_getAllOrders()
94 ashish 1203 
 
483 rajveer 1204 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1205 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1206 
    args = getAllOrders_args()
1207 
    args.status = status
1208 
    args.from_date = from_date
1209 
    args.to_date = to_date
1210 
    args.warehouse_id = warehouse_id
94 ashish 1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
483 rajveer 1215 
  def recv_getAllOrders(self, ):
94 ashish 1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
483 rajveer 1222 
    result = getAllOrders_result()
94 ashish 1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
94 ashish 1226 
      return result.success
3431 rajveer 1227 
    if result.ex is not None:
94 ashish 1228 
      raise result.ex
483 rajveer 1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1230 
 
4133 chandransh 1231 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1232 
    """
1233 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1234 
    Pass the status as null and the limit as 0 to ignore them.
1235 
 
1236 
    Parameters:
1237 
     - statuses
1238 
     - offset
1239 
     - limit
1240 
     - warehouse_id
1241 
    """
1242 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1243 
    return self.recv_getOrdersInBatch()
1244 
 
1245 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1246 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1247 
    args = getOrdersInBatch_args()
1248 
    args.statuses = statuses
1249 
    args.offset = offset
1250 
    args.limit = limit
1251 
    args.warehouse_id = warehouse_id
1252 
    args.write(self._oprot)
1253 
    self._oprot.writeMessageEnd()
1254 
    self._oprot.trans.flush()
1255 
 
1256 
  def recv_getOrdersInBatch(self, ):
1257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1258 
    if mtype == TMessageType.EXCEPTION:
1259 
      x = TApplicationException()
1260 
      x.read(self._iprot)
1261 
      self._iprot.readMessageEnd()
1262 
      raise x
1263 
    result = getOrdersInBatch_result()
1264 
    result.read(self._iprot)
1265 
    self._iprot.readMessageEnd()
1266 
    if result.success is not None:
1267 
      return result.success
1268 
    if result.ex is not None:
1269 
      raise result.ex
1270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1271 
 
1272 
  def getOrderCount(self, statuses, warehouseId):
1273 
    """
1274 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1275 
 
1276 
    Parameters:
1277 
     - statuses
1278 
     - warehouseId
1279 
    """
1280 
    self.send_getOrderCount(statuses, warehouseId)
1281 
    return self.recv_getOrderCount()
1282 
 
1283 
  def send_getOrderCount(self, statuses, warehouseId):
1284 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1285 
    args = getOrderCount_args()
1286 
    args.statuses = statuses
1287 
    args.warehouseId = warehouseId
1288 
    args.write(self._oprot)
1289 
    self._oprot.writeMessageEnd()
1290 
    self._oprot.trans.flush()
1291 
 
1292 
  def recv_getOrderCount(self, ):
1293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1294 
    if mtype == TMessageType.EXCEPTION:
1295 
      x = TApplicationException()
1296 
      x.read(self._iprot)
1297 
      self._iprot.readMessageEnd()
1298 
      raise x
1299 
    result = getOrderCount_result()
1300 
    result.read(self._iprot)
1301 
    self._iprot.readMessageEnd()
1302 
    if result.success is not None:
1303 
      return result.success
1304 
    if result.ex is not None:
1305 
      raise result.ex
1306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1307 
 
999 varun.gupt 1308 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1309 
    """
1132 chandransh 1310 
    Returns orders within a range of their billing dates
3431 rajveer 1311 
 
999 varun.gupt 1312 
    Parameters:
1313 
     - status
1314 
     - start_billing_date
1315 
     - end_billing_date
1316 
     - warehouse_id
1317 
    """
1318 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1319 
    return self.recv_getOrdersByBillingDate()
1320 
 
1321 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1322 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1323 
    args = getOrdersByBillingDate_args()
1324 
    args.status = status
1325 
    args.start_billing_date = start_billing_date
1326 
    args.end_billing_date = end_billing_date
1327 
    args.warehouse_id = warehouse_id
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getOrdersByBillingDate(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getOrdersByBillingDate_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
3431 rajveer 1342 
    if result.success is not None:
999 varun.gupt 1343 
      return result.success
3431 rajveer 1344 
    if result.ex is not None:
999 varun.gupt 1345 
      raise result.ex
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1347 
 
3451 chandransh 1348 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1349 
    """
1350 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1351 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1352 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1353 
 
3427 chandransh 1354 
    Parameters:
1355 
     - fromShippingDate
1356 
     - toShippingDate
1357 
     - providerId
1358 
     - warehouseId
3451 chandransh 1359 
     - cod
3427 chandransh 1360 
    """
3451 chandransh 1361 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1362 
    return self.recv_getOrdersByShippingDate()
1363 
 
3451 chandransh 1364 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1365 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1366 
    args = getOrdersByShippingDate_args()
1367 
    args.fromShippingDate = fromShippingDate
1368 
    args.toShippingDate = toShippingDate
1369 
    args.providerId = providerId
1370 
    args.warehouseId = warehouseId
3451 chandransh 1371 
    args.cod = cod
3427 chandransh 1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_getOrdersByShippingDate(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = getOrdersByShippingDate_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
3431 rajveer 1386 
    if result.success is not None:
3427 chandransh 1387 
      return result.success
3431 rajveer 1388 
    if result.ex is not None:
3427 chandransh 1389 
      raise result.ex
1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1391 
 
1382 varun.gupt 1392 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1393 
    """
1394 
    Returns order ids for orders which can be returned
3431 rajveer 1395 
 
1382 varun.gupt 1396 
    Parameters:
1397 
     - customer_id
1398 
     - limit
1399 
    """
1400 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1401 
    return self.recv_getReturnableOrdersForCustomer()
1402 
 
1403 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1404 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1405 
    args = getReturnableOrdersForCustomer_args()
1406 
    args.customer_id = customer_id
1407 
    args.limit = limit
1408 
    args.write(self._oprot)
1409 
    self._oprot.writeMessageEnd()
1410 
    self._oprot.trans.flush()
1411 
 
1412 
  def recv_getReturnableOrdersForCustomer(self, ):
1413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1414 
    if mtype == TMessageType.EXCEPTION:
1415 
      x = TApplicationException()
1416 
      x.read(self._iprot)
1417 
      self._iprot.readMessageEnd()
1418 
      raise x
1419 
    result = getReturnableOrdersForCustomer_result()
1420 
    result.read(self._iprot)
1421 
    self._iprot.readMessageEnd()
3431 rajveer 1422 
    if result.success is not None:
1382 varun.gupt 1423 
      return result.success
3431 rajveer 1424 
    if result.ex is not None:
1382 varun.gupt 1425 
      raise result.ex
1426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1427 
 
1428 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1429 
    """
1430 
    Returns order ids for orders which can be cancelled
3431 rajveer 1431 
 
1382 varun.gupt 1432 
    Parameters:
1433 
     - customer_id
1434 
     - limit
1435 
    """
1436 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1437 
    return self.recv_getCancellableOrdersForCustomer()
1438 
 
1439 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1440 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1441 
    args = getCancellableOrdersForCustomer_args()
1442 
    args.customer_id = customer_id
1443 
    args.limit = limit
1444 
    args.write(self._oprot)
1445 
    self._oprot.writeMessageEnd()
1446 
    self._oprot.trans.flush()
1447 
 
1448 
  def recv_getCancellableOrdersForCustomer(self, ):
1449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1450 
    if mtype == TMessageType.EXCEPTION:
1451 
      x = TApplicationException()
1452 
      x.read(self._iprot)
1453 
      self._iprot.readMessageEnd()
1454 
      raise x
1455 
    result = getCancellableOrdersForCustomer_result()
1456 
    result.read(self._iprot)
1457 
    self._iprot.readMessageEnd()
3431 rajveer 1458 
    if result.success is not None:
1382 varun.gupt 1459 
      return result.success
3431 rajveer 1460 
    if result.ex is not None:
1382 varun.gupt 1461 
      raise result.ex
1462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1463 
 
483 rajveer 1464 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1465 
    """
1466 
    Parameters:
483 rajveer 1467 
     - orderId
1468 
     - status
1469 
     - description
94 ashish 1470 
    """
483 rajveer 1471 
    self.send_changeOrderStatus(orderId, status, description)
1472 
    return self.recv_changeOrderStatus()
94 ashish 1473 
 
483 rajveer 1474 
  def send_changeOrderStatus(self, orderId, status, description):
1475 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1476 
    args = changeOrderStatus_args()
1477 
    args.orderId = orderId
1478 
    args.status = status
1479 
    args.description = description
94 ashish 1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
483 rajveer 1484 
  def recv_changeOrderStatus(self, ):
94 ashish 1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
483 rajveer 1491 
    result = changeOrderStatus_result()
94 ashish 1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
3431 rajveer 1494 
    if result.success is not None:
94 ashish 1495 
      return result.success
3431 rajveer 1496 
    if result.ex is not None:
94 ashish 1497 
      raise result.ex
483 rajveer 1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1499 
 
1528 ankur.sing 1500 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1501 
    """
1528 ankur.sing 1502 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1503 
    only user who owns the transaction can view its order details.
3431 rajveer 1504 
 
94 ashish 1505 
    Parameters:
1506 
     - transactionId
1528 ankur.sing 1507 
     - customerId
94 ashish 1508 
    """
1528 ankur.sing 1509 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1510 
    return self.recv_getOrdersForTransaction()
94 ashish 1511 
 
1528 ankur.sing 1512 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1513 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1514 
    args = getOrdersForTransaction_args()
94 ashish 1515 
    args.transactionId = transactionId
1528 ankur.sing 1516 
    args.customerId = customerId
94 ashish 1517 
    args.write(self._oprot)
1518 
    self._oprot.writeMessageEnd()
1519 
    self._oprot.trans.flush()
1520 
 
483 rajveer 1521 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1523 
    if mtype == TMessageType.EXCEPTION:
1524 
      x = TApplicationException()
1525 
      x.read(self._iprot)
1526 
      self._iprot.readMessageEnd()
1527 
      raise x
483 rajveer 1528 
    result = getOrdersForTransaction_result()
94 ashish 1529 
    result.read(self._iprot)
1530 
    self._iprot.readMessageEnd()
3431 rajveer 1531 
    if result.success is not None:
94 ashish 1532 
      return result.success
3431 rajveer 1533 
    if result.ex is not None:
94 ashish 1534 
      raise result.ex
483 rajveer 1535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1536 
 
3014 chandransh 1537 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1538 
    """
3014 chandransh 1539 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1540 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1541 
 
94 ashish 1542 
    Parameters:
483 rajveer 1543 
     - customerId
1544 
     - from_date
1545 
     - to_date
3014 chandransh 1546 
     - statuses
94 ashish 1547 
    """
3014 chandransh 1548 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1549 
    return self.recv_getOrdersForCustomer()
94 ashish 1550 
 
3014 chandransh 1551 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1552 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1553 
    args = getOrdersForCustomer_args()
1554 
    args.customerId = customerId
1555 
    args.from_date = from_date
1556 
    args.to_date = to_date
3014 chandransh 1557 
    args.statuses = statuses
94 ashish 1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
483 rajveer 1562 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
483 rajveer 1569 
    result = getOrdersForCustomer_result()
94 ashish 1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
3431 rajveer 1572 
    if result.success is not None:
94 ashish 1573 
      return result.success
3431 rajveer 1574 
    if result.ex is not None:
94 ashish 1575 
      raise result.ex
483 rajveer 1576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1577 
 
483 rajveer 1578 
  def createOrder(self, order):
94 ashish 1579 
    """
1580 
    Parameters:
483 rajveer 1581 
     - order
94 ashish 1582 
    """
483 rajveer 1583 
    self.send_createOrder(order)
1584 
    return self.recv_createOrder()
94 ashish 1585 
 
483 rajveer 1586 
  def send_createOrder(self, order):
1587 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1588 
    args = createOrder_args()
1589 
    args.order = order
94 ashish 1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
483 rajveer 1594 
  def recv_createOrder(self, ):
94 ashish 1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
483 rajveer 1601 
    result = createOrder_result()
94 ashish 1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
3431 rajveer 1604 
    if result.success is not None:
94 ashish 1605 
      return result.success
3431 rajveer 1606 
    if result.ex is not None:
94 ashish 1607 
      raise result.ex
483 rajveer 1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1609 
 
483 rajveer 1610 
  def getOrder(self, id):
94 ashish 1611 
    """
1612 
    Parameters:
483 rajveer 1613 
     - id
94 ashish 1614 
    """
483 rajveer 1615 
    self.send_getOrder(id)
1616 
    return self.recv_getOrder()
94 ashish 1617 
 
483 rajveer 1618 
  def send_getOrder(self, id):
1619 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1620 
    args = getOrder_args()
1621 
    args.id = id
94 ashish 1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
483 rajveer 1626 
  def recv_getOrder(self, ):
94 ashish 1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
483 rajveer 1633 
    result = getOrder_result()
94 ashish 1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
3431 rajveer 1636 
    if result.success is not None:
94 ashish 1637 
      return result.success
3431 rajveer 1638 
    if result.ex is not None:
94 ashish 1639 
      raise result.ex
483 rajveer 1640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1641 
 
483 rajveer 1642 
  def getLineItemsForOrder(self, orderId):
94 ashish 1643 
    """
1644 
    Parameters:
483 rajveer 1645 
     - orderId
94 ashish 1646 
    """
483 rajveer 1647 
    self.send_getLineItemsForOrder(orderId)
1648 
    return self.recv_getLineItemsForOrder()
94 ashish 1649 
 
483 rajveer 1650 
  def send_getLineItemsForOrder(self, orderId):
1651 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1652 
    args = getLineItemsForOrder_args()
1653 
    args.orderId = orderId
94 ashish 1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
483 rajveer 1658 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
483 rajveer 1665 
    result = getLineItemsForOrder_result()
94 ashish 1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
94 ashish 1669 
      return result.success
3431 rajveer 1670 
    if result.ex is not None:
94 ashish 1671 
      raise result.ex
483 rajveer 1672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1673 
 
1528 ankur.sing 1674 
  def getOrderForCustomer(self, orderId, customerId):
1675 
    """
1676 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1677 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1678 
 
1528 ankur.sing 1679 
    Parameters:
1680 
     - orderId
1681 
     - customerId
1682 
    """
1683 
    self.send_getOrderForCustomer(orderId, customerId)
1684 
    return self.recv_getOrderForCustomer()
1685 
 
1686 
  def send_getOrderForCustomer(self, orderId, customerId):
1687 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1688 
    args = getOrderForCustomer_args()
1689 
    args.orderId = orderId
1690 
    args.customerId = customerId
1691 
    args.write(self._oprot)
1692 
    self._oprot.writeMessageEnd()
1693 
    self._oprot.trans.flush()
1694 
 
1695 
  def recv_getOrderForCustomer(self, ):
1696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1697 
    if mtype == TMessageType.EXCEPTION:
1698 
      x = TApplicationException()
1699 
      x.read(self._iprot)
1700 
      self._iprot.readMessageEnd()
1701 
      raise x
1702 
    result = getOrderForCustomer_result()
1703 
    result.read(self._iprot)
1704 
    self._iprot.readMessageEnd()
3431 rajveer 1705 
    if result.success is not None:
1528 ankur.sing 1706 
      return result.success
3431 rajveer 1707 
    if result.ex is not None:
1528 ankur.sing 1708 
      raise result.ex
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1710 
 
4444 rajveer 1711 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1712 
    """
1713 
    Parameters:
4394 rajveer 1714 
     - type
4444 rajveer 1715 
     - warehouseId
4394 rajveer 1716 
     - status
1717 
     - timestamp
3064 chandransh 1718 
    """
4444 rajveer 1719 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1720 
    return self.recv_getAlerts()
1721 
 
4444 rajveer 1722 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1723 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1724 
    args = getAlerts_args()
4394 rajveer 1725 
    args.type = type
4444 rajveer 1726 
    args.warehouseId = warehouseId
4394 rajveer 1727 
    args.status = status
1728 
    args.timestamp = timestamp
3064 chandransh 1729 
    args.write(self._oprot)
1730 
    self._oprot.writeMessageEnd()
1731 
    self._oprot.trans.flush()
1732 
 
1733 
  def recv_getAlerts(self, ):
1734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1735 
    if mtype == TMessageType.EXCEPTION:
1736 
      x = TApplicationException()
1737 
      x.read(self._iprot)
1738 
      self._iprot.readMessageEnd()
1739 
      raise x
1740 
    result = getAlerts_result()
1741 
    result.read(self._iprot)
1742 
    self._iprot.readMessageEnd()
3431 rajveer 1743 
    if result.success is not None:
3064 chandransh 1744 
      return result.success
1745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1746 
 
4444 rajveer 1747 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1748 
    """
1749 
    Parameters:
1750 
     - type
4444 rajveer 1751 
     - warehouseId
4394 rajveer 1752 
     - description
3064 chandransh 1753 
    """
4444 rajveer 1754 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1755 
    self.recv_addAlert()
3064 chandransh 1756 
 
4444 rajveer 1757 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1758 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1759 
    args = addAlert_args()
3064 chandransh 1760 
    args.type = type
4444 rajveer 1761 
    args.warehouseId = warehouseId
4394 rajveer 1762 
    args.description = description
3064 chandransh 1763 
    args.write(self._oprot)
1764 
    self._oprot.writeMessageEnd()
1765 
    self._oprot.trans.flush()
1766 
 
4394 rajveer 1767 
  def recv_addAlert(self, ):
3064 chandransh 1768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1769 
    if mtype == TMessageType.EXCEPTION:
1770 
      x = TApplicationException()
1771 
      x.read(self._iprot)
1772 
      self._iprot.readMessageEnd()
1773 
      raise x
4394 rajveer 1774 
    result = addAlert_result()
3064 chandransh 1775 
    result.read(self._iprot)
1776 
    self._iprot.readMessageEnd()
1777 
    return
1778 
 
4444 rajveer 1779 
  def markAlertsAsSeen(self, warehouseId):
1780 
    """
1781 
    Parameters:
1782 
     - warehouseId
1783 
    """
1784 
    self.send_markAlertsAsSeen(warehouseId)
1785 
    self.recv_markAlertsAsSeen()
1786 
 
1787 
  def send_markAlertsAsSeen(self, warehouseId):
1788 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1789 
    args = markAlertsAsSeen_args()
1790 
    args.warehouseId = warehouseId
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_markAlertsAsSeen(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = markAlertsAsSeen_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    return
1806 
 
3064 chandransh 1807 
  def getValidOrderCount(self, ):
1808 
    """
1809 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1810 
    """
1811 
    self.send_getValidOrderCount()
1812 
    return self.recv_getValidOrderCount()
1813 
 
1814 
  def send_getValidOrderCount(self, ):
1815 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1816 
    args = getValidOrderCount_args()
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_getValidOrderCount(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = getValidOrderCount_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
3431 rajveer 1831 
    if result.success is not None:
3064 chandransh 1832 
      return result.success
1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1834 
 
1835 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1836 
    """
1837 
    Returns the number of distinct customers who have done successful transactions
1838 
    """
1839 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1840 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1841 
 
1842 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1843 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1844 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
1849 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
1856 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
3431 rajveer 1859 
    if result.success is not None:
3064 chandransh 1860 
      return result.success
1861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1862 
 
1863 
  def getValidOrdersAmountRange(self, ):
1864 
    """
1865 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1866 
    List contains two values, first minimum amount and second maximum amount.
1867 
    """
1868 
    self.send_getValidOrdersAmountRange()
1869 
    return self.recv_getValidOrdersAmountRange()
1870 
 
1871 
  def send_getValidOrdersAmountRange(self, ):
1872 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1873 
    args = getValidOrdersAmountRange_args()
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getValidOrdersAmountRange(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getValidOrdersAmountRange_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
3064 chandransh 1889 
      return result.success
1890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1891 
 
1892 
  def getValidOrders(self, limit):
1893 
    """
1894 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1895 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1896 
 
3064 chandransh 1897 
    Parameters:
1898 
     - limit
1899 
    """
1900 
    self.send_getValidOrders(limit)
1901 
    return self.recv_getValidOrders()
1902 
 
1903 
  def send_getValidOrders(self, limit):
1904 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1905 
    args = getValidOrders_args()
1906 
    args.limit = limit
1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
1911 
  def recv_getValidOrders(self, ):
1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
1918 
    result = getValidOrders_result()
1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
3064 chandransh 1922 
      return result.success
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1924 
 
1220 chandransh 1925 
  def batchOrders(self, warehouseId):
1926 
    """
1927 
    Create a batch of all the pending orders for the given warehouse.
1928 
    The returned list is orderd by created_timestamp.
1929 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1930 
 
1220 chandransh 1931 
    Parameters:
1932 
     - warehouseId
1933 
    """
1934 
    self.send_batchOrders(warehouseId)
1935 
    return self.recv_batchOrders()
1936 
 
1937 
  def send_batchOrders(self, warehouseId):
1938 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1939 
    args = batchOrders_args()
1940 
    args.warehouseId = warehouseId
1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
1945 
  def recv_batchOrders(self, ):
1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
1952 
    result = batchOrders_result()
1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
3431 rajveer 1955 
    if result.success is not None:
1220 chandransh 1956 
      return result.success
3431 rajveer 1957 
    if result.ex is not None:
1220 chandransh 1958 
      raise result.ex
1959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1960 
 
1208 chandransh 1961 
  def markOrderAsOutOfStock(self, orderId):
1962 
    """
1963 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1964 
 
1208 chandransh 1965 
    Parameters:
1966 
     - orderId
1967 
    """
1968 
    self.send_markOrderAsOutOfStock(orderId)
1969 
    return self.recv_markOrderAsOutOfStock()
1970 
 
1971 
  def send_markOrderAsOutOfStock(self, orderId):
1972 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1973 
    args = markOrderAsOutOfStock_args()
1974 
    args.orderId = orderId
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_markOrderAsOutOfStock(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = markOrderAsOutOfStock_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
3431 rajveer 1989 
    if result.success is not None:
1208 chandransh 1990 
      return result.success
3431 rajveer 1991 
    if result.ex is not None:
1208 chandransh 1992 
      raise result.ex
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1994 
 
3064 chandransh 1995 
  def verifyOrder(self, orderId):
759 chandransh 1996 
    """
3064 chandransh 1997 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1998 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1999 
    used for all other orders as well.
2000 
    Throws an exception if no such order exists.
3431 rajveer 2001 
 
759 chandransh 2002 
    Parameters:
3064 chandransh 2003 
     - orderId
759 chandransh 2004 
    """
3064 chandransh 2005 
    self.send_verifyOrder(orderId)
2006 
    return self.recv_verifyOrder()
759 chandransh 2007 
 
3064 chandransh 2008 
  def send_verifyOrder(self, orderId):
2009 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2010 
    args = verifyOrder_args()
2011 
    args.orderId = orderId
759 chandransh 2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
3064 chandransh 2016 
  def recv_verifyOrder(self, ):
759 chandransh 2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
3064 chandransh 2023 
    result = verifyOrder_result()
759 chandransh 2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
3431 rajveer 2026 
    if result.success is not None:
759 chandransh 2027 
      return result.success
3431 rajveer 2028 
    if result.ex is not None:
759 chandransh 2029 
      raise result.ex
3064 chandransh 2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2031 
 
3064 chandransh 2032 
  def acceptOrder(self, orderId):
1113 chandransh 2033 
    """
3064 chandransh 2034 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2035 
    given order is not a COD order, it also captures the payment if the same has
2036 
    not been captured.
2037 
    Throws an exception if no such order exists.
3431 rajveer 2038 
 
1113 chandransh 2039 
    Parameters:
3064 chandransh 2040 
     - orderId
1113 chandransh 2041 
    """
3064 chandransh 2042 
    self.send_acceptOrder(orderId)
2043 
    return self.recv_acceptOrder()
1113 chandransh 2044 
 
3064 chandransh 2045 
  def send_acceptOrder(self, orderId):
2046 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2047 
    args = acceptOrder_args()
2048 
    args.orderId = orderId
1113 chandransh 2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
3064 chandransh 2053 
  def recv_acceptOrder(self, ):
1113 chandransh 2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
3064 chandransh 2060 
    result = acceptOrder_result()
1113 chandransh 2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
3431 rajveer 2063 
    if result.success is not None:
1113 chandransh 2064 
      return result.success
3431 rajveer 2065 
    if result.ex is not None:
1113 chandransh 2066 
      raise result.ex
3064 chandransh 2067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2068 
 
4283 anupam.sin 2069 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2070 
    """
3064 chandransh 2071 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2072 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2073 
    the IMEI no. if a -1 is supplied.
2074 
    Also, it generates an invoice number for the order, marks the order as
2075 
    BILLED and sets the billing timestamp.
2076 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2077 
 
1135 chandransh 2078 
    Parameters:
3064 chandransh 2079 
     - orderId
2080 
     - invoice_number
4283 anupam.sin 2081 
     - imeiNumber
2082 
     - itemNumber
3064 chandransh 2083 
     - billed_by
4264 rajveer 2084 
     - jacketNumber
4283 anupam.sin 2085 
     - billingType
2086 
     - vendorId
1135 chandransh 2087 
    """
4283 anupam.sin 2088 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2089 
    return self.recv_addBillingDetails()
1135 chandransh 2090 
 
4283 anupam.sin 2091 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2092 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2093 
    args = addBillingDetails_args()
2094 
    args.orderId = orderId
2095 
    args.invoice_number = invoice_number
4283 anupam.sin 2096 
    args.imeiNumber = imeiNumber
2097 
    args.itemNumber = itemNumber
3064 chandransh 2098 
    args.billed_by = billed_by
4264 rajveer 2099 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2100 
    args.billingType = billingType
2101 
    args.vendorId = vendorId
1135 chandransh 2102 
    args.write(self._oprot)
2103 
    self._oprot.writeMessageEnd()
2104 
    self._oprot.trans.flush()
2105 
 
3064 chandransh 2106 
  def recv_addBillingDetails(self, ):
1135 chandransh 2107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2108 
    if mtype == TMessageType.EXCEPTION:
2109 
      x = TApplicationException()
2110 
      x.read(self._iprot)
2111 
      self._iprot.readMessageEnd()
2112 
      raise x
3064 chandransh 2113 
    result = addBillingDetails_result()
1135 chandransh 2114 
    result.read(self._iprot)
2115 
    self._iprot.readMessageEnd()
3431 rajveer 2116 
    if result.success is not None:
3064 chandransh 2117 
      return result.success
3431 rajveer 2118 
    if result.ex is not None:
1135 chandransh 2119 
      raise result.ex
3064 chandransh 2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2121 
 
4579 rajveer 2122 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2123 
    """
2124 
    Add the invoice number to the order.
2125 
 
2126 
    Parameters:
2127 
     - orderId
2128 
     - invoiceNumber
2129 
    """
2130 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2131 
    self.recv_addInvoiceNumber()
2132 
 
2133 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2134 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2135 
    args = addInvoiceNumber_args()
2136 
    args.orderId = orderId
2137 
    args.invoiceNumber = invoiceNumber
2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
2142 
  def recv_addInvoiceNumber(self, ):
2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
2149 
    result = addInvoiceNumber_result()
2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
2152 
    if result.ex is not None:
2153 
      raise result.ex
2154 
    return
2155 
 
3064 chandransh 2156 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2157 
    """
3064 chandransh 2158 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2159 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2160 
 
1408 ankur.sing 2161 
    Parameters:
3064 chandransh 2162 
     - warehouseId
1408 ankur.sing 2163 
     - providerId
3064 chandransh 2164 
     - cod
1408 ankur.sing 2165 
    """
3064 chandransh 2166 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2167 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2168 
 
3064 chandransh 2169 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2170 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2171 
    args = markOrdersAsManifested_args()
2172 
    args.warehouseId = warehouseId
1408 ankur.sing 2173 
    args.providerId = providerId
3064 chandransh 2174 
    args.cod = cod
1408 ankur.sing 2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
3064 chandransh 2179 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
3064 chandransh 2186 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
1408 ankur.sing 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
3064 chandransh 2192 
      raise result.ex
2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2194 
 
4410 rajveer 2195 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2196 
    """
2197 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2198 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2199 
 
2200 
    Parameters:
2201 
     - warehouseId
2202 
     - providerId
2203 
     - cod
2204 
    """
2205 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2206 
    return self.recv_markOrdersAsShippedFromWarehouse()
2207 
 
2208 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2209 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2210 
    args = markOrdersAsShippedFromWarehouse_args()
2211 
    args.warehouseId = warehouseId
2212 
    args.providerId = providerId
2213 
    args.cod = cod
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = markOrdersAsShippedFromWarehouse_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
2228 
    if result.success is not None:
2229 
      return result.success
2230 
    if result.ex is not None:
2231 
      raise result.ex
2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2233 
 
3064 chandransh 2234 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2235 
    """
3064 chandransh 2236 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2237 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2238 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2239 
 
94 ashish 2240 
    Parameters:
3064 chandransh 2241 
     - providerId
2242 
     - pickupDetails
304 ashish 2243 
    """
3064 chandransh 2244 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2245 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2246 
 
3064 chandransh 2247 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2248 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2249 
    args = markOrdersAsPickedUp_args()
2250 
    args.providerId = providerId
2251 
    args.pickupDetails = pickupDetails
304 ashish 2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
3064 chandransh 2256 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
3064 chandransh 2263 
    result = markOrdersAsPickedUp_result()
304 ashish 2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
3431 rajveer 2266 
    if result.success is not None:
304 ashish 2267 
      return result.success
3431 rajveer 2268 
    if result.ex is not None:
3064 chandransh 2269 
      raise result.ex
2270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2271 
 
3064 chandransh 2272 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2273 
    """
3064 chandransh 2274 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2275 
    the name of the receiver.
2276 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2277 
 
304 ashish 2278 
    Parameters:
3064 chandransh 2279 
     - providerId
2280 
     - deliveredOrders
304 ashish 2281 
    """
3064 chandransh 2282 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2283 
    self.recv_markOrdersAsDelivered()
304 ashish 2284 
 
3064 chandransh 2285 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2286 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2287 
    args = markOrdersAsDelivered_args()
2288 
    args.providerId = providerId
2289 
    args.deliveredOrders = deliveredOrders
304 ashish 2290 
    args.write(self._oprot)
2291 
    self._oprot.writeMessageEnd()
2292 
    self._oprot.trans.flush()
2293 
 
3064 chandransh 2294 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2296 
    if mtype == TMessageType.EXCEPTION:
2297 
      x = TApplicationException()
2298 
      x.read(self._iprot)
2299 
      self._iprot.readMessageEnd()
2300 
      raise x
3064 chandransh 2301 
    result = markOrdersAsDelivered_result()
304 ashish 2302 
    result.read(self._iprot)
2303 
    self._iprot.readMessageEnd()
3431 rajveer 2304 
    if result.ex is not None:
3064 chandransh 2305 
      raise result.ex
304 ashish 2306 
    return
2307 
 
3064 chandransh 2308 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2309 
    """
3064 chandransh 2310 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2311 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2312 
 
3064 chandransh 2313 
    Parameters:
2314 
     - providerId
2315 
     - returnedOrders
1596 ankur.sing 2316 
    """
3064 chandransh 2317 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2318 
    self.recv_markOrdersAsFailed()
304 ashish 2319 
 
3064 chandransh 2320 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2321 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2322 
    args = markOrdersAsFailed_args()
2323 
    args.providerId = providerId
2324 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2325 
    args.write(self._oprot)
2326 
    self._oprot.writeMessageEnd()
2327 
    self._oprot.trans.flush()
2328 
 
3064 chandransh 2329 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2331 
    if mtype == TMessageType.EXCEPTION:
2332 
      x = TApplicationException()
2333 
      x.read(self._iprot)
2334 
      self._iprot.readMessageEnd()
2335 
      raise x
3064 chandransh 2336 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2337 
    result.read(self._iprot)
2338 
    self._iprot.readMessageEnd()
3431 rajveer 2339 
    if result.ex is not None:
3064 chandransh 2340 
      raise result.ex
2341 
    return
1596 ankur.sing 2342 
 
3064 chandransh 2343 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2344 
    """
3064 chandransh 2345 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2346 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2347 
 
3064 chandransh 2348 
    Parameters:
2349 
     - providerId
2350 
     - undeliveredOrders
1627 ankur.sing 2351 
    """
3064 chandransh 2352 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2353 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2354 
 
3064 chandransh 2355 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2356 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2357 
    args = updateNonDeliveryReason_args()
2358 
    args.providerId = providerId
2359 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2360 
    args.write(self._oprot)
2361 
    self._oprot.writeMessageEnd()
2362 
    self._oprot.trans.flush()
2363 
 
3064 chandransh 2364 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2366 
    if mtype == TMessageType.EXCEPTION:
2367 
      x = TApplicationException()
2368 
      x.read(self._iprot)
2369 
      self._iprot.readMessageEnd()
2370 
      raise x
3064 chandransh 2371 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2372 
    result.read(self._iprot)
2373 
    self._iprot.readMessageEnd()
4581 phani.kuma 2374 
    if result.success is not None:
2375 
      return result.success
3431 rajveer 2376 
    if result.ex is not None:
3064 chandransh 2377 
      raise result.ex
4581 phani.kuma 2378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2379 
 
3064 chandransh 2380 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2381 
    """
3064 chandransh 2382 
    Returns the list of orders whose delivery time has passed but have not been
2383 
    delivered yet for the given provider and warehouse. To get a complete list of
2384 
    undelivered orders, pass them as -1.
2385 
    Returns an empty list if no such orders exist.
3431 rajveer 2386 
 
1886 ankur.sing 2387 
    Parameters:
3064 chandransh 2388 
     - providerId
2389 
     - warehouseId
1886 ankur.sing 2390 
    """
3064 chandransh 2391 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2392 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2393 
 
3064 chandransh 2394 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2395 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2396 
    args = getUndeliveredOrders_args()
2397 
    args.providerId = providerId
2398 
    args.warehouseId = warehouseId
1886 ankur.sing 2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
3064 chandransh 2403 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
3064 chandransh 2410 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
3431 rajveer 2413 
    if result.success is not None:
1886 ankur.sing 2414 
      return result.success
3064 chandransh 2415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2416 
 
2536 chandransh 2417 
  def toggleDOAFlag(self, orderId):
2418 
    """
2419 
    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.
2420 
    Returns the final flag status.
2421 
    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 2422 
 
2536 chandransh 2423 
    Parameters:
2424 
     - orderId
2425 
    """
2426 
    self.send_toggleDOAFlag(orderId)
2427 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2428 
 
2536 chandransh 2429 
  def send_toggleDOAFlag(self, orderId):
2430 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2431 
    args = toggleDOAFlag_args()
2432 
    args.orderId = orderId
2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
2437 
  def recv_toggleDOAFlag(self, ):
2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
2444 
    result = toggleDOAFlag_result()
2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
3431 rajveer 2447 
    if result.success is not None:
2536 chandransh 2448 
      return result.success
3431 rajveer 2449 
    if result.ex is not None:
2536 chandransh 2450 
      raise result.ex
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2452 
 
4454 rajveer 2453 
  def markOrderDoaRequestReceived(self, orderId):
2454 
    """
2455 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2456 
 
2457 
    Parameters:
2458 
     - orderId
2459 
    """
2460 
    self.send_markOrderDoaRequestReceived(orderId)
2461 
    return self.recv_markOrderDoaRequestReceived()
2462 
 
2463 
  def send_markOrderDoaRequestReceived(self, orderId):
2464 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2465 
    args = markOrderDoaRequestReceived_args()
2466 
    args.orderId = orderId
2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
2471 
  def recv_markOrderDoaRequestReceived(self, ):
2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
2478 
    result = markOrderDoaRequestReceived_result()
2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
2481 
    if result.success is not None:
2482 
      return result.success
2483 
    if result.ex is not None:
2484 
      raise result.ex
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2486 
 
2487 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2488 
    """
2489 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2490 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2491 
 
2492 
    Parameters:
2493 
     - orderId
2494 
     - isAuthorized
2495 
    """
2496 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2497 
    return self.recv_markOrderDoaRequestAuthorized()
2498 
 
2499 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2500 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2501 
    args = markOrderDoaRequestAuthorized_args()
2502 
    args.orderId = orderId
2503 
    args.isAuthorized = isAuthorized
2504 
    args.write(self._oprot)
2505 
    self._oprot.writeMessageEnd()
2506 
    self._oprot.trans.flush()
2507 
 
2508 
  def recv_markOrderDoaRequestAuthorized(self, ):
2509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2510 
    if mtype == TMessageType.EXCEPTION:
2511 
      x = TApplicationException()
2512 
      x.read(self._iprot)
2513 
      self._iprot.readMessageEnd()
2514 
      raise x
2515 
    result = markOrderDoaRequestAuthorized_result()
2516 
    result.read(self._iprot)
2517 
    self._iprot.readMessageEnd()
2518 
    if result.success is not None:
2519 
      return result.success
2520 
    if result.ex is not None:
2521 
      raise result.ex
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2523 
 
4488 rajveer 2524 
  def markOrderReturnRequestReceived(self, orderId):
2525 
    """
2526 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2527 
 
2528 
    Parameters:
2529 
     - orderId
2530 
    """
2531 
    self.send_markOrderReturnRequestReceived(orderId)
2532 
    return self.recv_markOrderReturnRequestReceived()
2533 
 
2534 
  def send_markOrderReturnRequestReceived(self, orderId):
2535 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2536 
    args = markOrderReturnRequestReceived_args()
2537 
    args.orderId = orderId
2538 
    args.write(self._oprot)
2539 
    self._oprot.writeMessageEnd()
2540 
    self._oprot.trans.flush()
2541 
 
2542 
  def recv_markOrderReturnRequestReceived(self, ):
2543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2544 
    if mtype == TMessageType.EXCEPTION:
2545 
      x = TApplicationException()
2546 
      x.read(self._iprot)
2547 
      self._iprot.readMessageEnd()
2548 
      raise x
2549 
    result = markOrderReturnRequestReceived_result()
2550 
    result.read(self._iprot)
2551 
    self._iprot.readMessageEnd()
2552 
    if result.success is not None:
2553 
      return result.success
2554 
    if result.ex is not None:
2555 
      raise result.ex
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2557 
 
2558 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2559 
    """
2560 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2561 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2562 
 
2563 
    Parameters:
2564 
     - orderId
2565 
     - isAuthorized
2566 
    """
2567 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2568 
    return self.recv_markOrderReturnRequestAuthorized()
2569 
 
2570 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2571 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2572 
    args = markOrderReturnRequestAuthorized_args()
2573 
    args.orderId = orderId
2574 
    args.isAuthorized = isAuthorized
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_markOrderReturnRequestAuthorized(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = markOrderReturnRequestAuthorized_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
2589 
    if result.success is not None:
2590 
      return result.success
2591 
    if result.ex is not None:
2592 
      raise result.ex
2593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2594 
 
4579 rajveer 2595 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2596 
    """
2597 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2598 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2599 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2600 
    For any other status, it returns false.
2601 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2602 
 
2536 chandransh 2603 
    Parameters:
2604 
     - orderId
4579 rajveer 2605 
     - providerId
2536 chandransh 2606 
    """
4579 rajveer 2607 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2608 
    return self.recv_requestPickupNumber()
2609 
 
4579 rajveer 2610 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2611 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2612 
    args = requestPickupNumber_args()
2613 
    args.orderId = orderId
4579 rajveer 2614 
    args.providerId = providerId
2536 chandransh 2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_requestPickupNumber(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = requestPickupNumber_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
3431 rajveer 2629 
    if result.success is not None:
2536 chandransh 2630 
      return result.success
3431 rajveer 2631 
    if result.ex is not None:
2536 chandransh 2632 
      raise result.ex
2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2634 
 
4602 rajveer 2635 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2636 
    """
4452 rajveer 2637 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2638 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2639 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2640 
    	3. Returns true
2591 chandransh 2641 
    If the order is in any other status, it returns false.
2536 chandransh 2642 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2643 
 
2536 chandransh 2644 
    Parameters:
2645 
     - orderId
2646 
     - pickupNumber
4602 rajveer 2647 
     - providerId
2536 chandransh 2648 
    """
4602 rajveer 2649 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2650 
    return self.recv_authorizePickup()
2651 
 
4602 rajveer 2652 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2653 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2654 
    args = authorizePickup_args()
2655 
    args.orderId = orderId
2656 
    args.pickupNumber = pickupNumber
4602 rajveer 2657 
    args.providerId = providerId
2536 chandransh 2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2662 
  def recv_authorizePickup(self, ):
2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2669 
    result = authorizePickup_result()
2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
3431 rajveer 2672 
    if result.success is not None:
2536 chandransh 2673 
      return result.success
3431 rajveer 2674 
    if result.ex is not None:
2536 chandransh 2675 
      raise result.ex
2676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2677 
 
2764 chandransh 2678 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2679 
    """
2680 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2681 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2682 
 
2764 chandransh 2683 
    Parameters:
2684 
     - providerId
2685 
     - pickupDetails
2686 
    """
2687 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2688 
    return self.recv_markDoasAsPickedUp()
2689 
 
2690 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2691 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2692 
    args = markDoasAsPickedUp_args()
2693 
    args.providerId = providerId
2694 
    args.pickupDetails = pickupDetails
2695 
    args.write(self._oprot)
2696 
    self._oprot.writeMessageEnd()
2697 
    self._oprot.trans.flush()
2698 
 
2699 
  def recv_markDoasAsPickedUp(self, ):
2700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2701 
    if mtype == TMessageType.EXCEPTION:
2702 
      x = TApplicationException()
2703 
      x.read(self._iprot)
2704 
      self._iprot.readMessageEnd()
2705 
      raise x
2706 
    result = markDoasAsPickedUp_result()
2707 
    result.read(self._iprot)
2708 
    self._iprot.readMessageEnd()
3431 rajveer 2709 
    if result.success is not None:
2764 chandransh 2710 
      return result.success
2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2712 
 
4479 rajveer 2713 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2714 
    """
4452 rajveer 2715 
    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 2716 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2717 
    If the order is in any other state, it returns false.
2718 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2719 
 
2591 chandransh 2720 
    Parameters:
2721 
     - orderId
4479 rajveer 2722 
     - receiveCondition
2591 chandransh 2723 
    """
4479 rajveer 2724 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2725 
    return self.recv_receiveReturn()
2536 chandransh 2726 
 
4479 rajveer 2727 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2728 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2729 
    args = receiveReturn_args()
2591 chandransh 2730 
    args.orderId = orderId
4479 rajveer 2731 
    args.receiveCondition = receiveCondition
2591 chandransh 2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
2616 chandransh 2736 
  def recv_receiveReturn(self, ):
2591 chandransh 2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
2616 chandransh 2743 
    result = receiveReturn_result()
2591 chandransh 2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
3431 rajveer 2746 
    if result.success is not None:
2591 chandransh 2747 
      return result.success
3431 rajveer 2748 
    if result.ex is not None:
2591 chandransh 2749 
      raise result.ex
2616 chandransh 2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2751 
 
2752 
  def validateDoa(self, orderId, isValid):
2753 
    """
4452 rajveer 2754 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2755 
    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 2756 
    If the order is in any other state, it returns false.
2757 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2758 
 
2591 chandransh 2759 
    Parameters:
2760 
     - orderId
2761 
     - isValid
2762 
    """
2763 
    self.send_validateDoa(orderId, isValid)
2764 
    return self.recv_validateDoa()
2765 
 
2766 
  def send_validateDoa(self, orderId, isValid):
2767 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2768 
    args = validateDoa_args()
2769 
    args.orderId = orderId
2770 
    args.isValid = isValid
2771 
    args.write(self._oprot)
2772 
    self._oprot.writeMessageEnd()
2773 
    self._oprot.trans.flush()
2774 
 
2775 
  def recv_validateDoa(self, ):
2776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2777 
    if mtype == TMessageType.EXCEPTION:
2778 
      x = TApplicationException()
2779 
      x.read(self._iprot)
2780 
      self._iprot.readMessageEnd()
2781 
      raise x
2782 
    result = validateDoa_result()
2783 
    result.read(self._iprot)
2784 
    self._iprot.readMessageEnd()
3431 rajveer 2785 
    if result.success is not None:
2591 chandransh 2786 
      return result.success
3431 rajveer 2787 
    if result.ex is not None:
2591 chandransh 2788 
      raise result.ex
2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2790 
 
4495 rajveer 2791 
  def validateReturnProduct(self, orderId, isUsable):
2792 
    """
2793 
    Parameters:
2794 
     - orderId
2795 
     - isUsable
2796 
    """
2797 
    self.send_validateReturnProduct(orderId, isUsable)
2798 
    return self.recv_validateReturnProduct()
2799 
 
2800 
  def send_validateReturnProduct(self, orderId, isUsable):
2801 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2802 
    args = validateReturnProduct_args()
2803 
    args.orderId = orderId
2804 
    args.isUsable = isUsable
2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
2809 
  def recv_validateReturnProduct(self, ):
2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
2816 
    result = validateReturnProduct_result()
2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
2819 
    if result.success is not None:
2820 
      return result.success
2821 
    if result.ex is not None:
2822 
      raise result.ex
2823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2824 
 
2616 chandransh 2825 
  def reshipOrder(self, orderId):
2826 
    """
4484 rajveer 2827 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2828 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2829 
    	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 2830 
 
2831 
    If the order is in DOA_CERT_VALID state, it does the following:
2832 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2833 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2834 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2835 
 
2616 chandransh 2836 
    Returns the id of the newly created order.
3431 rajveer 2837 
 
2616 chandransh 2838 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2839 
 
2616 chandransh 2840 
    Parameters:
2841 
     - orderId
2842 
    """
2843 
    self.send_reshipOrder(orderId)
2844 
    return self.recv_reshipOrder()
2591 chandransh 2845 
 
2616 chandransh 2846 
  def send_reshipOrder(self, orderId):
2847 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2848 
    args = reshipOrder_args()
2849 
    args.orderId = orderId
2850 
    args.write(self._oprot)
2851 
    self._oprot.writeMessageEnd()
2852 
    self._oprot.trans.flush()
2853 
 
2854 
  def recv_reshipOrder(self, ):
2855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2856 
    if mtype == TMessageType.EXCEPTION:
2857 
      x = TApplicationException()
2858 
      x.read(self._iprot)
2859 
      self._iprot.readMessageEnd()
2860 
      raise x
2861 
    result = reshipOrder_result()
2862 
    result.read(self._iprot)
2863 
    self._iprot.readMessageEnd()
3431 rajveer 2864 
    if result.success is not None:
2616 chandransh 2865 
      return result.success
3431 rajveer 2866 
    if result.ex is not None:
2616 chandransh 2867 
      raise result.ex
2868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2869 
 
3226 chandransh 2870 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2871 
    """
4484 rajveer 2872 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2873 
    	1. Creates a refund request for batch processing.
2874 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2875 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2876 
 
2616 chandransh 2877 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2878 
    	1. Creates a refund request for batch processing.
3226 chandransh 2879 
    	2. Cancels the reservation of the item in the warehouse.
2880 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2881 
 
3226 chandransh 2882 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2883 
    	1. Cancels the reservation of the item in the warehouse.
2884 
    	2. Marks the current order as CANCELED.
2885 
 
2886 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2887 
 
2616 chandransh 2888 
    Returns True if it is successful, False otherwise.
3431 rajveer 2889 
 
2616 chandransh 2890 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2891 
 
2616 chandransh 2892 
    Parameters:
2893 
     - orderId
3226 chandransh 2894 
     - refundedBy
2895 
     - reason
2616 chandransh 2896 
    """
3226 chandransh 2897 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2898 
    return self.recv_refundOrder()
2899 
 
3226 chandransh 2900 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2901 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2902 
    args = refundOrder_args()
2903 
    args.orderId = orderId
3226 chandransh 2904 
    args.refundedBy = refundedBy
2905 
    args.reason = reason
2616 chandransh 2906 
    args.write(self._oprot)
2907 
    self._oprot.writeMessageEnd()
2908 
    self._oprot.trans.flush()
2909 
 
2910 
  def recv_refundOrder(self, ):
2911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2912 
    if mtype == TMessageType.EXCEPTION:
2913 
      x = TApplicationException()
2914 
      x.read(self._iprot)
2915 
      self._iprot.readMessageEnd()
2916 
      raise x
2917 
    result = refundOrder_result()
2918 
    result.read(self._iprot)
2919 
    self._iprot.readMessageEnd()
3431 rajveer 2920 
    if result.success is not None:
2616 chandransh 2921 
      return result.success
3431 rajveer 2922 
    if result.ex is not None:
2616 chandransh 2923 
      raise result.ex
2924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2925 
 
2690 chandransh 2926 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2927 
    """
2928 
    Get all return orders created between the from and to dates for the given warehouse.
2929 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2930 
 
2690 chandransh 2931 
    Parameters:
2932 
     - warehouseId
2933 
     - fromDate
2934 
     - toDate
2935 
    """
2936 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2937 
    return self.recv_getReturnOrders()
2616 chandransh 2938 
 
2690 chandransh 2939 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2940 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2941 
    args = getReturnOrders_args()
2942 
    args.warehouseId = warehouseId
2943 
    args.fromDate = fromDate
2944 
    args.toDate = toDate
2945 
    args.write(self._oprot)
2946 
    self._oprot.writeMessageEnd()
2947 
    self._oprot.trans.flush()
2948 
 
2949 
  def recv_getReturnOrders(self, ):
2950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2951 
    if mtype == TMessageType.EXCEPTION:
2952 
      x = TApplicationException()
2953 
      x.read(self._iprot)
2954 
      self._iprot.readMessageEnd()
2955 
      raise x
2956 
    result = getReturnOrders_result()
2957 
    result.read(self._iprot)
2958 
    self._iprot.readMessageEnd()
3431 rajveer 2959 
    if result.success is not None:
2690 chandransh 2960 
      return result.success
2961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2962 
 
2700 chandransh 2963 
  def getReturnOrder(self, id):
2964 
    """
2965 
    Returns the ReturnOrder corresponding to the given id.
2966 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2967 
 
2700 chandransh 2968 
    Parameters:
2969 
     - id
2970 
    """
2971 
    self.send_getReturnOrder(id)
2972 
    return self.recv_getReturnOrder()
2973 
 
2974 
  def send_getReturnOrder(self, id):
2975 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2976 
    args = getReturnOrder_args()
2977 
    args.id = id
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_getReturnOrder(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = getReturnOrder_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
3431 rajveer 2992 
    if result.success is not None:
2700 chandransh 2993 
      return result.success
3431 rajveer 2994 
    if result.ex is not None:
2700 chandransh 2995 
      raise result.ex
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2997 
 
2690 chandransh 2998 
  def processReturn(self, returnOrderId):
2999 
    """
3000 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3001 
 
2690 chandransh 3002 
    Parameters:
3003 
     - returnOrderId
3004 
    """
3005 
    self.send_processReturn(returnOrderId)
3006 
    self.recv_processReturn()
3007 
 
3008 
  def send_processReturn(self, returnOrderId):
3009 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3010 
    args = processReturn_args()
3011 
    args.returnOrderId = returnOrderId
3012 
    args.write(self._oprot)
3013 
    self._oprot.writeMessageEnd()
3014 
    self._oprot.trans.flush()
3015 
 
3016 
  def recv_processReturn(self, ):
3017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3018 
    if mtype == TMessageType.EXCEPTION:
3019 
      x = TApplicationException()
3020 
      x.read(self._iprot)
3021 
      self._iprot.readMessageEnd()
3022 
      raise x
3023 
    result = processReturn_result()
3024 
    result.read(self._iprot)
3025 
    self._iprot.readMessageEnd()
3431 rajveer 3026 
    if result.ex is not None:
2690 chandransh 3027 
      raise result.ex
3028 
    return
3029 
 
2819 chandransh 3030 
  def createPurchaseOrder(self, warehouseId):
3031 
    """
4586 mandeep.dh 3032 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3033 
    Returns the list of PO no. of the newly created purchase order.
3034 
    Returns null if no new purchase order had to be created.
3431 rajveer 3035 
 
2819 chandransh 3036 
    Parameters:
3037 
     - warehouseId
3038 
    """
3039 
    self.send_createPurchaseOrder(warehouseId)
3040 
    return self.recv_createPurchaseOrder()
2690 chandransh 3041 
 
2819 chandransh 3042 
  def send_createPurchaseOrder(self, warehouseId):
3043 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3044 
    args = createPurchaseOrder_args()
3045 
    args.warehouseId = warehouseId
3046 
    args.write(self._oprot)
3047 
    self._oprot.writeMessageEnd()
3048 
    self._oprot.trans.flush()
3049 
 
3050 
  def recv_createPurchaseOrder(self, ):
3051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3052 
    if mtype == TMessageType.EXCEPTION:
3053 
      x = TApplicationException()
3054 
      x.read(self._iprot)
3055 
      self._iprot.readMessageEnd()
3056 
      raise x
3057 
    result = createPurchaseOrder_result()
3058 
    result.read(self._iprot)
3059 
    self._iprot.readMessageEnd()
3431 rajveer 3060 
    if result.success is not None:
2819 chandransh 3061 
      return result.success
3431 rajveer 3062 
    if result.ex is not None:
2819 chandransh 3063 
      raise result.ex
3064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3065 
 
3451 chandransh 3066 
  def updateWeight(self, orderId, weight):
3067 
    """
3068 
    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 3069 
 
3451 chandransh 3070 
    Parameters:
3071 
     - orderId
3072 
     - weight
3073 
    """
3074 
    self.send_updateWeight(orderId, weight)
3075 
    return self.recv_updateWeight()
3076 
 
3077 
  def send_updateWeight(self, orderId, weight):
3078 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3079 
    args = updateWeight_args()
3080 
    args.orderId = orderId
3081 
    args.weight = weight
3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_updateWeight(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = updateWeight_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3096 
    if result.success is not None:
3097 
      return result.success
3098 
    if result.ex is not None:
3099 
      raise result.ex
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3101 
 
3469 chandransh 3102 
  def changeItem(self, orderId, itemId):
3103 
    """
3104 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3105 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3106 
 
3469 chandransh 3107 
    Parameters:
3108 
     - orderId
3109 
     - itemId
3110 
    """
3111 
    self.send_changeItem(orderId, itemId)
3112 
    return self.recv_changeItem()
3113 
 
3114 
  def send_changeItem(self, orderId, itemId):
3115 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3116 
    args = changeItem_args()
3117 
    args.orderId = orderId
3118 
    args.itemId = itemId
3119 
    args.write(self._oprot)
3120 
    self._oprot.writeMessageEnd()
3121 
    self._oprot.trans.flush()
3122 
 
3123 
  def recv_changeItem(self, ):
3124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3125 
    if mtype == TMessageType.EXCEPTION:
3126 
      x = TApplicationException()
3127 
      x.read(self._iprot)
3128 
      self._iprot.readMessageEnd()
3129 
      raise x
3130 
    result = changeItem_result()
3131 
    result.read(self._iprot)
3132 
    self._iprot.readMessageEnd()
3133 
    if result.success is not None:
3134 
      return result.success
3135 
    if result.ex is not None:
3136 
      raise result.ex
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3138 
 
3139 
  def shiftToWarehouse(self, orderId, warehouseId):
3140 
    """
3141 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3142 
 
3143 
    Parameters:
3144 
     - orderId
3145 
     - warehouseId
3146 
    """
3147 
    self.send_shiftToWarehouse(orderId, warehouseId)
3148 
    return self.recv_shiftToWarehouse()
3149 
 
3150 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3151 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3152 
    args = shiftToWarehouse_args()
3153 
    args.orderId = orderId
3154 
    args.warehouseId = warehouseId
3155 
    args.write(self._oprot)
3156 
    self._oprot.writeMessageEnd()
3157 
    self._oprot.trans.flush()
3158 
 
3159 
  def recv_shiftToWarehouse(self, ):
3160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3161 
    if mtype == TMessageType.EXCEPTION:
3162 
      x = TApplicationException()
3163 
      x.read(self._iprot)
3164 
      self._iprot.readMessageEnd()
3165 
      raise x
3166 
    result = shiftToWarehouse_result()
3167 
    result.read(self._iprot)
3168 
    self._iprot.readMessageEnd()
3169 
    if result.success is not None:
3170 
      return result.success
3171 
    if result.ex is not None:
3172 
      raise result.ex
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3174 
 
3986 chandransh 3175 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3176 
    """
3177 
    Adds the given delay reason to the given order.
3986 chandransh 3178 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3179 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3180 
 
3553 chandransh 3181 
    Parameters:
3182 
     - orderId
3183 
     - delayReason
3986 chandransh 3184 
     - furtherDelay
3553 chandransh 3185 
    """
3986 chandransh 3186 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3187 
    return self.recv_addDelayReason()
3188 
 
3986 chandransh 3189 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3190 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3191 
    args = addDelayReason_args()
3192 
    args.orderId = orderId
3193 
    args.delayReason = delayReason
3986 chandransh 3194 
    args.furtherDelay = furtherDelay
3553 chandransh 3195 
    args.write(self._oprot)
3196 
    self._oprot.writeMessageEnd()
3197 
    self._oprot.trans.flush()
3198 
 
3199 
  def recv_addDelayReason(self, ):
3200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3201 
    if mtype == TMessageType.EXCEPTION:
3202 
      x = TApplicationException()
3203 
      x.read(self._iprot)
3204 
      self._iprot.readMessageEnd()
3205 
      raise x
3206 
    result = addDelayReason_result()
3207 
    result.read(self._iprot)
3208 
    self._iprot.readMessageEnd()
3209 
    if result.success is not None:
3210 
      return result.success
3211 
    if result.ex is not None:
3212 
      raise result.ex
3213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3214 
 
3956 chandransh 3215 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3216 
    """
3217 
    Marks the COD orders with given AWB nos. as having been processed.
3218 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3219 
 
3956 chandransh 3220 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3221 
    1. There is no order corresponding to an AWB number.
3222 
    2. The captured amount for a payment exceeds the total payment.
3223 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3224 
 
3225 
    Parameters:
3226 
     - collectedAmountMap
3227 
     - xferBy
3228 
     - xferTxnId
3229 
     - xferDate
3230 
    """
3231 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3232 
    return self.recv_reconcileCodCollection()
3233 
 
3234 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3235 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3236 
    args = reconcileCodCollection_args()
3237 
    args.collectedAmountMap = collectedAmountMap
3238 
    args.xferBy = xferBy
3239 
    args.xferTxnId = xferTxnId
3240 
    args.xferDate = xferDate
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_reconcileCodCollection(self, ):
3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3252 
    result = reconcileCodCollection_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3255 
    if result.success is not None:
3256 
      return result.success
3257 
    if result.ex is not None:
3258 
      raise result.ex
3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3260 
 
4008 mandeep.dh 3261 
  def getTransactionsRequiringExtraProcessing(self, category):
3262 
    """
4065 mandeep.dh 3263 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3264 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3265 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3266 
 
4008 mandeep.dh 3267 
    Parameters:
3268 
     - category
3269 
    """
3270 
    self.send_getTransactionsRequiringExtraProcessing(category)
3271 
    return self.recv_getTransactionsRequiringExtraProcessing()
3272 
 
3273 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3274 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3275 
    args = getTransactionsRequiringExtraProcessing_args()
3276 
    args.category = category
3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = getTransactionsRequiringExtraProcessing_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
3291 
    if result.success is not None:
3292 
      return result.success
3293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3294 
 
3295 
  def markTransactionAsProcessed(self, transactionId, category):
3296 
    """
3297 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3298 
    It essentially deletes the transaction id record for a particular
3299 
    processing type category (if present) from DB.
3300 
    This is currently used by CRM application.
4008 mandeep.dh 3301 
 
3302 
    Parameters:
3303 
     - transactionId
3304 
     - category
3305 
    """
3306 
    self.send_markTransactionAsProcessed(transactionId, category)
3307 
    self.recv_markTransactionAsProcessed()
3308 
 
3309 
  def send_markTransactionAsProcessed(self, transactionId, category):
3310 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3311 
    args = markTransactionAsProcessed_args()
3312 
    args.transactionId = transactionId
3313 
    args.category = category
3314 
    args.write(self._oprot)
3315 
    self._oprot.writeMessageEnd()
3316 
    self._oprot.trans.flush()
3317 
 
3318 
  def recv_markTransactionAsProcessed(self, ):
3319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3320 
    if mtype == TMessageType.EXCEPTION:
3321 
      x = TApplicationException()
3322 
      x.read(self._iprot)
3323 
      self._iprot.readMessageEnd()
3324 
      raise x
3325 
    result = markTransactionAsProcessed_result()
3326 
    result.read(self._iprot)
3327 
    self._iprot.readMessageEnd()
3328 
    return
3329 
 
4018 chandransh 3330 
  def getItemWiseRiskyOrdersCount(self, ):
3331 
    """
3332 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3333 
    is defined as one whose shipping date is about to expire.
3334 
    """
3335 
    self.send_getItemWiseRiskyOrdersCount()
3336 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3337 
 
4018 chandransh 3338 
  def send_getItemWiseRiskyOrdersCount(self, ):
3339 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3340 
    args = getItemWiseRiskyOrdersCount_args()
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = getItemWiseRiskyOrdersCount_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3355 
    if result.success is not None:
3356 
      return result.success
3357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3358 
 
4295 varun.gupt 3359 
  def getOrdersForItemIds(self, itemIds):
3360 
    """
3361 
    Returns a list of all orders which have items with given id
3362 
 
3363 
    Parameters:
3364 
     - itemIds
3365 
    """
3366 
    self.send_getOrdersForItemIds(itemIds)
3367 
    return self.recv_getOrdersForItemIds()
3368 
 
3369 
  def send_getOrdersForItemIds(self, itemIds):
3370 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3371 
    args = getOrdersForItemIds_args()
3372 
    args.itemIds = itemIds
3373 
    args.write(self._oprot)
3374 
    self._oprot.writeMessageEnd()
3375 
    self._oprot.trans.flush()
3376 
 
3377 
  def recv_getOrdersForItemIds(self, ):
3378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3379 
    if mtype == TMessageType.EXCEPTION:
3380 
      x = TApplicationException()
3381 
      x.read(self._iprot)
3382 
      self._iprot.readMessageEnd()
3383 
      raise x
3384 
    result = getOrdersForItemIds_result()
3385 
    result.read(self._iprot)
3386 
    self._iprot.readMessageEnd()
3387 
    if result.success is not None:
3388 
      return result.success
3389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3390 
 
4247 rajveer 3391 
  def markOrderCancellationRequestReceived(self, orderId):
3392 
    """
3393 
    Mark order as cancellation request received. If customer sends request of cancellation of
3394 
    a particular order, this method will be called. It will just change status of the order
3395 
    depending on its current status. It also records the previous status, so that we can move
3396 
    back to that status if cancellation request is denied.
4018 chandransh 3397 
 
4247 rajveer 3398 
    Parameters:
3399 
     - orderId
3400 
    """
3401 
    self.send_markOrderCancellationRequestReceived(orderId)
3402 
    self.recv_markOrderCancellationRequestReceived()
3403 
 
3404 
  def send_markOrderCancellationRequestReceived(self, orderId):
3405 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3406 
    args = markOrderCancellationRequestReceived_args()
3407 
    args.orderId = orderId
3408 
    args.write(self._oprot)
3409 
    self._oprot.writeMessageEnd()
3410 
    self._oprot.trans.flush()
3411 
 
3412 
  def recv_markOrderCancellationRequestReceived(self, ):
3413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3414 
    if mtype == TMessageType.EXCEPTION:
3415 
      x = TApplicationException()
3416 
      x.read(self._iprot)
3417 
      self._iprot.readMessageEnd()
3418 
      raise x
3419 
    result = markOrderCancellationRequestReceived_result()
3420 
    result.read(self._iprot)
3421 
    self._iprot.readMessageEnd()
3422 
    if result.ex is not None:
3423 
      raise result.ex
3424 
    return
3425 
 
3426 
  def markOrderCancellationRequestConfirmed(self, orderId):
3427 
    """
3428 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3429 
    cancellation request confirmed. After this OM will be able to cancel the order.
3430 
 
3431 
    Parameters:
3432 
     - orderId
3433 
    """
3434 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3435 
    self.recv_markOrderCancellationRequestConfirmed()
3436 
 
3437 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3438 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3439 
    args = markOrderCancellationRequestConfirmed_args()
3440 
    args.orderId = orderId
3441 
    args.write(self._oprot)
3442 
    self._oprot.writeMessageEnd()
3443 
    self._oprot.trans.flush()
3444 
 
3445 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3447 
    if mtype == TMessageType.EXCEPTION:
3448 
      x = TApplicationException()
3449 
      x.read(self._iprot)
3450 
      self._iprot.readMessageEnd()
3451 
      raise x
3452 
    result = markOrderCancellationRequestConfirmed_result()
3453 
    result.read(self._iprot)
3454 
    self._iprot.readMessageEnd()
3455 
    if result.ex is not None:
3456 
      raise result.ex
3457 
    return
3458 
 
3459 
  def markOrderCancellationRequestDenied(self, orderId):
3460 
    """
3461 
    If we decide to not to cancel order, we will move the order ro previous status.
3462 
 
3463 
    Parameters:
3464 
     - orderId
3465 
    """
3466 
    self.send_markOrderCancellationRequestDenied(orderId)
3467 
    self.recv_markOrderCancellationRequestDenied()
3468 
 
3469 
  def send_markOrderCancellationRequestDenied(self, orderId):
3470 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3471 
    args = markOrderCancellationRequestDenied_args()
3472 
    args.orderId = orderId
3473 
    args.write(self._oprot)
3474 
    self._oprot.writeMessageEnd()
3475 
    self._oprot.trans.flush()
3476 
 
3477 
  def recv_markOrderCancellationRequestDenied(self, ):
3478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3479 
    if mtype == TMessageType.EXCEPTION:
3480 
      x = TApplicationException()
3481 
      x.read(self._iprot)
3482 
      self._iprot.readMessageEnd()
3483 
      raise x
3484 
    result = markOrderCancellationRequestDenied_result()
3485 
    result.read(self._iprot)
3486 
    self._iprot.readMessageEnd()
3487 
    if result.ex is not None:
3488 
      raise result.ex
3489 
    return
3490 
 
4258 rajveer 3491 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3492 
    """
4258 rajveer 3493 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3494 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3495 
 
3496 
    Parameters:
4258 rajveer 3497 
     - transactionId
4247 rajveer 3498 
    """
4258 rajveer 3499 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3500 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3501 
 
4258 rajveer 3502 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3503 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3504 
    args = markTransactionAsPaymentFlagRemoved_args()
3505 
    args.transactionId = transactionId
4247 rajveer 3506 
    args.write(self._oprot)
3507 
    self._oprot.writeMessageEnd()
3508 
    self._oprot.trans.flush()
3509 
 
4258 rajveer 3510 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3512 
    if mtype == TMessageType.EXCEPTION:
3513 
      x = TApplicationException()
3514 
      x.read(self._iprot)
3515 
      self._iprot.readMessageEnd()
3516 
      raise x
4258 rajveer 3517 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3518 
    result.read(self._iprot)
3519 
    self._iprot.readMessageEnd()
3520 
    if result.ex is not None:
3521 
      raise result.ex
3522 
    return
3523 
 
4259 anupam.sin 3524 
  def refundTransaction(self, transactionId, refundedBy, reason):
3525 
    """
3526 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3527 
    need to be cancelled
4247 rajveer 3528 
 
4259 anupam.sin 3529 
    Parameters:
3530 
     - transactionId
3531 
     - refundedBy
3532 
     - reason
3533 
    """
3534 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3535 
    self.recv_refundTransaction()
3536 
 
3537 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3538 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3539 
    args = refundTransaction_args()
3540 
    args.transactionId = transactionId
3541 
    args.refundedBy = refundedBy
3542 
    args.reason = reason
3543 
    args.write(self._oprot)
3544 
    self._oprot.writeMessageEnd()
3545 
    self._oprot.trans.flush()
3546 
 
3547 
  def recv_refundTransaction(self, ):
3548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3549 
    if mtype == TMessageType.EXCEPTION:
3550 
      x = TApplicationException()
3551 
      x.read(self._iprot)
3552 
      self._iprot.readMessageEnd()
3553 
      raise x
3554 
    result = refundTransaction_result()
3555 
    result.read(self._iprot)
3556 
    self._iprot.readMessageEnd()
3557 
    if result.ex is not None:
3558 
      raise result.ex
3559 
    return
3560 
 
4324 mandeep.dh 3561 
  def updateShipmentAddress(self, orderId, addressId):
3562 
    """
3563 
    Updates shipment address of an order. Delivery and shipping date estimates
3564 
    etc. are also updated here.
3565 
 
3566 
    Throws TransactionServiceException in case address change is not
3567 
    possible due to certain reasons such as new pincode in address is
3568 
    not serviceable etc.
3569 
 
3570 
    Parameters:
3571 
     - orderId
3572 
     - addressId
3573 
    """
3574 
    self.send_updateShipmentAddress(orderId, addressId)
3575 
    self.recv_updateShipmentAddress()
3576 
 
3577 
  def send_updateShipmentAddress(self, orderId, addressId):
3578 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3579 
    args = updateShipmentAddress_args()
3580 
    args.orderId = orderId
3581 
    args.addressId = addressId
3582 
    args.write(self._oprot)
3583 
    self._oprot.writeMessageEnd()
3584 
    self._oprot.trans.flush()
3585 
 
3586 
  def recv_updateShipmentAddress(self, ):
3587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3588 
    if mtype == TMessageType.EXCEPTION:
3589 
      x = TApplicationException()
3590 
      x.read(self._iprot)
3591 
      self._iprot.readMessageEnd()
3592 
      raise x
3593 
    result = updateShipmentAddress_result()
3594 
    result.read(self._iprot)
3595 
    self._iprot.readMessageEnd()
3596 
    if result.ex is not None:
3597 
      raise result.ex
3598 
    return
3599 
 
4285 rajveer 3600 
  def acceptOrdersForItemId(self, itemId, inventory):
3601 
    """
3602 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3603 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3604 
 
4285 rajveer 3605 
    Parameters:
3606 
     - itemId
3607 
     - inventory
3608 
    """
3609 
    self.send_acceptOrdersForItemId(itemId, inventory)
3610 
    return self.recv_acceptOrdersForItemId()
3611 
 
3612 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3613 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3614 
    args = acceptOrdersForItemId_args()
3615 
    args.itemId = itemId
3616 
    args.inventory = inventory
3617 
    args.write(self._oprot)
3618 
    self._oprot.writeMessageEnd()
3619 
    self._oprot.trans.flush()
3620 
 
3621 
  def recv_acceptOrdersForItemId(self, ):
3622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3623 
    if mtype == TMessageType.EXCEPTION:
3624 
      x = TApplicationException()
3625 
      x.read(self._iprot)
3626 
      self._iprot.readMessageEnd()
3627 
      raise x
3628 
    result = acceptOrdersForItemId_result()
3629 
    result.read(self._iprot)
3630 
    self._iprot.readMessageEnd()
3631 
    if result.success is not None:
3632 
      return result.success
3633 
    if result.ex is not None:
3634 
      raise result.ex
3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3636 
 
4369 rajveer 3637 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3638 
    """
3639 
    Parameters:
3640 
     - vendorId
3641 
     - itemId
3642 
     - quantity
3643 
     - estimate
4369 rajveer 3644 
     - isReminder
4303 rajveer 3645 
    """
4369 rajveer 3646 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3647 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3648 
 
4369 rajveer 3649 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3650 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3651 
    args = markOrdersAsPORaised_args()
3652 
    args.vendorId = vendorId
3653 
    args.itemId = itemId
3654 
    args.quantity = quantity
3655 
    args.estimate = estimate
4369 rajveer 3656 
    args.isReminder = isReminder
4303 rajveer 3657 
    args.write(self._oprot)
3658 
    self._oprot.writeMessageEnd()
3659 
    self._oprot.trans.flush()
3660 
 
3661 
  def recv_markOrdersAsPORaised(self, ):
3662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3663 
    if mtype == TMessageType.EXCEPTION:
3664 
      x = TApplicationException()
3665 
      x.read(self._iprot)
3666 
      self._iprot.readMessageEnd()
3667 
      raise x
3668 
    result = markOrdersAsPORaised_result()
3669 
    result.read(self._iprot)
3670 
    self._iprot.readMessageEnd()
3671 
    if result.ex is not None:
3672 
      raise result.ex
3673 
    return
3674 
 
4369 rajveer 3675 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3676 
    """
3677 
    Parameters:
3678 
     - vendorId
3679 
     - itemId
3680 
     - quantity
3681 
     - estimate
4369 rajveer 3682 
     - isReminder
4303 rajveer 3683 
    """
4369 rajveer 3684 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3685 
    self.recv_markOrdersAsReversalInitiated()
3686 
 
4369 rajveer 3687 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3688 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3689 
    args = markOrdersAsReversalInitiated_args()
3690 
    args.vendorId = vendorId
3691 
    args.itemId = itemId
3692 
    args.quantity = quantity
3693 
    args.estimate = estimate
4369 rajveer 3694 
    args.isReminder = isReminder
4303 rajveer 3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_markOrdersAsReversalInitiated(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = markOrdersAsReversalInitiated_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3709 
    if result.ex is not None:
3710 
      raise result.ex
3711 
    return
3712 
 
4369 rajveer 3713 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3714 
    """
3715 
    Parameters:
3716 
     - vendorId
3717 
     - itemId
3718 
     - quantity
3719 
     - estimate
4369 rajveer 3720 
     - isReminder
4303 rajveer 3721 
    """
4369 rajveer 3722 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3723 
    self.recv_markOrdersAsNotAvailabke()
3724 
 
4369 rajveer 3725 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3726 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3727 
    args = markOrdersAsNotAvailabke_args()
3728 
    args.vendorId = vendorId
3729 
    args.itemId = itemId
3730 
    args.quantity = quantity
3731 
    args.estimate = estimate
4369 rajveer 3732 
    args.isReminder = isReminder
4303 rajveer 3733 
    args.write(self._oprot)
3734 
    self._oprot.writeMessageEnd()
3735 
    self._oprot.trans.flush()
3736 
 
3737 
  def recv_markOrdersAsNotAvailabke(self, ):
3738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3739 
    if mtype == TMessageType.EXCEPTION:
3740 
      x = TApplicationException()
3741 
      x.read(self._iprot)
3742 
      self._iprot.readMessageEnd()
3743 
      raise x
3744 
    result = markOrdersAsNotAvailabke_result()
3745 
    result.read(self._iprot)
3746 
    self._iprot.readMessageEnd()
3747 
    if result.ex is not None:
3748 
      raise result.ex
3749 
    return
3750 
 
4369 rajveer 3751 
  def markOrdersAsTimeout(self, vendorId):
3752 
    """
3753 
    Parameters:
3754 
     - vendorId
3755 
    """
3756 
    self.send_markOrdersAsTimeout(vendorId)
3757 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3758 
 
4369 rajveer 3759 
  def send_markOrdersAsTimeout(self, vendorId):
3760 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3761 
    args = markOrdersAsTimeout_args()
3762 
    args.vendorId = vendorId
3763 
    args.write(self._oprot)
3764 
    self._oprot.writeMessageEnd()
3765 
    self._oprot.trans.flush()
3766 
 
3767 
  def recv_markOrdersAsTimeout(self, ):
3768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3769 
    if mtype == TMessageType.EXCEPTION:
3770 
      x = TApplicationException()
3771 
      x.read(self._iprot)
3772 
      self._iprot.readMessageEnd()
3773 
      raise x
3774 
    result = markOrdersAsTimeout_result()
3775 
    result.read(self._iprot)
3776 
    self._iprot.readMessageEnd()
3777 
    if result.success is not None:
3778 
      return result.success
3779 
    if result.ex is not None:
3780 
      raise result.ex
3781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3782 
 
4386 anupam.sin 3783 
  def getOrderForAwb(self, awb):
3784 
    """
3785 
    Returns the order corresponding to an AWB number
4369 rajveer 3786 
 
4386 anupam.sin 3787 
    Parameters:
3788 
     - awb
3789 
    """
3790 
    self.send_getOrderForAwb(awb)
3791 
    return self.recv_getOrderForAwb()
3792 
 
3793 
  def send_getOrderForAwb(self, awb):
3794 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3795 
    args = getOrderForAwb_args()
3796 
    args.awb = awb
3797 
    args.write(self._oprot)
3798 
    self._oprot.writeMessageEnd()
3799 
    self._oprot.trans.flush()
3800 
 
3801 
  def recv_getOrderForAwb(self, ):
3802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3803 
    if mtype == TMessageType.EXCEPTION:
3804 
      x = TApplicationException()
3805 
      x.read(self._iprot)
3806 
      self._iprot.readMessageEnd()
3807 
      raise x
3808 
    result = getOrderForAwb_result()
3809 
    result.read(self._iprot)
3810 
    self._iprot.readMessageEnd()
3811 
    if result.success is not None:
3812 
      return result.success
3813 
    if result.ex is not None:
3814 
      raise result.ex
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3816 
 
4506 phani.kuma 3817 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3818 
    """
3819 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3820 
 
4506 phani.kuma 3821 
    Parameters:
3822 
     - logistics_provider_id
3823 
     - order_status
3824 
    """
3825 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3826 
    return self.recv_getOrdersForProviderForStatus()
3827 
 
3828 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3829 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3830 
    args = getOrdersForProviderForStatus_args()
3831 
    args.logistics_provider_id = logistics_provider_id
3832 
    args.order_status = order_status
3833 
    args.write(self._oprot)
3834 
    self._oprot.writeMessageEnd()
3835 
    self._oprot.trans.flush()
3836 
 
3837 
  def recv_getOrdersForProviderForStatus(self, ):
3838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3839 
    if mtype == TMessageType.EXCEPTION:
3840 
      x = TApplicationException()
3841 
      x.read(self._iprot)
3842 
      self._iprot.readMessageEnd()
3843 
      raise x
3844 
    result = getOrdersForProviderForStatus_result()
3845 
    result.read(self._iprot)
3846 
    self._iprot.readMessageEnd()
3847 
    if result.success is not None:
3848 
      return result.success
3849 
    if result.ex is not None:
3850 
      raise result.ex
3851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3852 
 
4600 varun.gupt 3853 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3854 
    """
3855 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3856 
 
4600 varun.gupt 3857 
    Parameters:
3858 
     - vendorId
3859 
     - billingDateFrom
3860 
     - billingDateTo
3861 
    """
3862 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3863 
    return self.recv_getBilledOrdersForVendor()
3864 
 
3865 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3866 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3867 
    args = getBilledOrdersForVendor_args()
3868 
    args.vendorId = vendorId
3869 
    args.billingDateFrom = billingDateFrom
3870 
    args.billingDateTo = billingDateTo
3871 
    args.write(self._oprot)
3872 
    self._oprot.writeMessageEnd()
3873 
    self._oprot.trans.flush()
3874 
 
3875 
  def recv_getBilledOrdersForVendor(self, ):
3876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3877 
    if mtype == TMessageType.EXCEPTION:
3878 
      x = TApplicationException()
3879 
      x.read(self._iprot)
3880 
      self._iprot.readMessageEnd()
3881 
      raise x
3882 
    result = getBilledOrdersForVendor_result()
3883 
    result.read(self._iprot)
3884 
    self._iprot.readMessageEnd()
3885 
    if result.success is not None:
3886 
      return result.success
3887 
    if result.ex is not None:
3888 
      raise result.ex
3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3890 
 
3891 
  def saveBluedartSettlements(self, mapAWBAndAmount):
3892 
    """
3893 
    Parameters:
3894 
     - mapAWBAndAmount
3895 
    """
3896 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
3897 
    self.recv_saveBluedartSettlements()
3898 
 
3899 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
3900 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
3901 
    args = saveBluedartSettlements_args()
3902 
    args.mapAWBAndAmount = mapAWBAndAmount
3903 
    args.write(self._oprot)
3904 
    self._oprot.writeMessageEnd()
3905 
    self._oprot.trans.flush()
3906 
 
3907 
  def recv_saveBluedartSettlements(self, ):
3908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3909 
    if mtype == TMessageType.EXCEPTION:
3910 
      x = TApplicationException()
3911 
      x.read(self._iprot)
3912 
      self._iprot.readMessageEnd()
3913 
      raise x
3914 
    result = saveBluedartSettlements_result()
3915 
    result.read(self._iprot)
3916 
    self._iprot.readMessageEnd()
3917 
    if result.ex is not None:
3918 
      raise result.ex
3919 
    return
3920 
 
3921 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3922 
    """
3923 
    Parameters:
3924 
     - settlementDate
3925 
     - paymentGatewayId
3926 
     - paymentId
3927 
     - serviceTax
3928 
     - otherCharges
3929 
     - netCollection
3930 
    """
3931 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
3932 
    self.recv_savePaymentSettlements()
3933 
 
3934 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3935 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
3936 
    args = savePaymentSettlements_args()
3937 
    args.settlementDate = settlementDate
3938 
    args.paymentGatewayId = paymentGatewayId
3939 
    args.paymentId = paymentId
3940 
    args.serviceTax = serviceTax
3941 
    args.otherCharges = otherCharges
3942 
    args.netCollection = netCollection
3943 
    args.write(self._oprot)
3944 
    self._oprot.writeMessageEnd()
3945 
    self._oprot.trans.flush()
3946 
 
3947 
  def recv_savePaymentSettlements(self, ):
3948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3949 
    if mtype == TMessageType.EXCEPTION:
3950 
      x = TApplicationException()
3951 
      x.read(self._iprot)
3952 
      self._iprot.readMessageEnd()
3953 
      raise x
3954 
    result = savePaymentSettlements_result()
3955 
    result.read(self._iprot)
3956 
    self._iprot.readMessageEnd()
3957 
    if result.ex is not None:
3958 
      raise result.ex
3959 
    return
3960 
 
3961 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3962 
    """
3963 
    Parameters:
3964 
     - settlementId
3965 
     - settlementDate
3966 
     - transactionDateFrom
3967 
     - transactionDateTo
3968 
     - amount
3969 
    """
3970 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
3971 
    self.recv_saveEBSSettlementSummary()
3972 
 
3973 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3974 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
3975 
    args = saveEBSSettlementSummary_args()
3976 
    args.settlementId = settlementId
3977 
    args.settlementDate = settlementDate
3978 
    args.transactionDateFrom = transactionDateFrom
3979 
    args.transactionDateTo = transactionDateTo
3980 
    args.amount = amount
3981 
    args.write(self._oprot)
3982 
    self._oprot.writeMessageEnd()
3983 
    self._oprot.trans.flush()
3984 
 
3985 
  def recv_saveEBSSettlementSummary(self, ):
3986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3987 
    if mtype == TMessageType.EXCEPTION:
3988 
      x = TApplicationException()
3989 
      x.read(self._iprot)
3990 
      self._iprot.readMessageEnd()
3991 
      raise x
3992 
    result = saveEBSSettlementSummary_result()
3993 
    result.read(self._iprot)
3994 
    self._iprot.readMessageEnd()
3995 
    if result.ex is not None:
3996 
      raise result.ex
3997 
    return
3998 
 
3999 
  def getSettlementForPaymentId(self, paymentId):
4000 
    """
4001 
    Parameters:
4002 
     - paymentId
4003 
    """
4004 
    self.send_getSettlementForPaymentId(paymentId)
4005 
    return self.recv_getSettlementForPaymentId()
4006 
 
4007 
  def send_getSettlementForPaymentId(self, paymentId):
4008 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4009 
    args = getSettlementForPaymentId_args()
4010 
    args.paymentId = paymentId
4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4015 
  def recv_getSettlementForPaymentId(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 = getSettlementForPaymentId_result()
4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
4025 
    if result.success is not None:
4026 
      return result.success
4027 
    if result.ex is not None:
4028 
      raise result.ex
4029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4030 
 
4031 
  def getEBSSettlementSummaries(self, ):
4032 
    self.send_getEBSSettlementSummaries()
4033 
    return self.recv_getEBSSettlementSummaries()
4034 
 
4035 
  def send_getEBSSettlementSummaries(self, ):
4036 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4037 
    args = getEBSSettlementSummaries_args()
4038 
    args.write(self._oprot)
4039 
    self._oprot.writeMessageEnd()
4040 
    self._oprot.trans.flush()
4041 
 
4042 
  def recv_getEBSSettlementSummaries(self, ):
4043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4044 
    if mtype == TMessageType.EXCEPTION:
4045 
      x = TApplicationException()
4046 
      x.read(self._iprot)
4047 
      self._iprot.readMessageEnd()
4048 
      raise x
4049 
    result = getEBSSettlementSummaries_result()
4050 
    result.read(self._iprot)
4051 
    self._iprot.readMessageEnd()
4052 
    if result.success is not None:
4053 
      return result.success
4054 
    if result.ex is not None:
4055 
      raise result.ex
4056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4057 
 
4058 
  def markEBSSettlementUploaded(self, settlementId):
4059 
    """
4060 
    Parameters:
4061 
     - settlementId
4062 
    """
4063 
    self.send_markEBSSettlementUploaded(settlementId)
4064 
    self.recv_markEBSSettlementUploaded()
4065 
 
4066 
  def send_markEBSSettlementUploaded(self, settlementId):
4067 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4068 
    args = markEBSSettlementUploaded_args()
4069 
    args.settlementId = settlementId
4070 
    args.write(self._oprot)
4071 
    self._oprot.writeMessageEnd()
4072 
    self._oprot.trans.flush()
4073 
 
4074 
  def recv_markEBSSettlementUploaded(self, ):
4075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4076 
    if mtype == TMessageType.EXCEPTION:
4077 
      x = TApplicationException()
4078 
      x.read(self._iprot)
4079 
      self._iprot.readMessageEnd()
4080 
      raise x
4081 
    result = markEBSSettlementUploaded_result()
4082 
    result.read(self._iprot)
4083 
    self._iprot.readMessageEnd()
4084 
    if result.ex is not None:
4085 
      raise result.ex
4086 
    return
4087 
 
4088 
  def getEBSSettlementDate(self, settlementId):
4089 
    """
4090 
    Parameters:
4091 
     - settlementId
4092 
    """
4093 
    self.send_getEBSSettlementDate(settlementId)
4094 
    return self.recv_getEBSSettlementDate()
4095 
 
4096 
  def send_getEBSSettlementDate(self, settlementId):
4097 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4098 
    args = getEBSSettlementDate_args()
4099 
    args.settlementId = settlementId
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_getEBSSettlementDate(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 = getEBSSettlementDate_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.success is not None:
4115 
      return result.success
4116 
    if result.ex is not None:
4117 
      raise result.ex
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4119 
 
4120 
 
3376 rajveer 4121 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4122 
  def __init__(self, handler):
3376 rajveer 4123 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4124 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4125 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4126 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4127 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4128 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4129 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4130 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4131 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4132 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4133 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4134 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4135 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4136 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4137 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4138 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4139 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4140 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4141 
    self._processMap["createOrder"] = Processor.process_createOrder
4142 
    self._processMap["getOrder"] = Processor.process_getOrder
4143 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4144 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4145 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4146 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4147 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4148 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4149 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4150 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4151 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4152 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4153 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4154 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4155 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4156 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4157 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4158 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4159 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4160 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4161 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4162 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4163 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4164 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4165 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4166 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4167 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4168 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4169 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4170 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4171 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4172 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4173 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4174 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4175 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4176 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4177 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4178 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4179 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4180 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4181 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4182 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4183 
    self._processMap["changeItem"] = Processor.process_changeItem
4184 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4185 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4186 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4187 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4188 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4189 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4190 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4191 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4192 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4193 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4194 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4195 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4196 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4197 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4198 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4199 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4200 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4201 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 4202 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4203 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4204 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4205 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4206 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4207 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4208 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4209 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4210 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4211 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4212 
 
4213 
  def process(self, iprot, oprot):
4214 
    (name, type, seqid) = iprot.readMessageBegin()
4215 
    if name not in self._processMap:
4216 
      iprot.skip(TType.STRUCT)
4217 
      iprot.readMessageEnd()
4218 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4219 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4220 
      x.write(oprot)
4221 
      oprot.writeMessageEnd()
4222 
      oprot.trans.flush()
4223 
      return
4224 
    else:
4225 
      self._processMap[name](self, seqid, iprot, oprot)
4226 
    return True
4227 
 
4228 
  def process_createTransaction(self, seqid, iprot, oprot):
4229 
    args = createTransaction_args()
4230 
    args.read(iprot)
4231 
    iprot.readMessageEnd()
4232 
    result = createTransaction_result()
4233 
    try:
132 ashish 4234 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4235 
    except TransactionServiceException, ex:
4236 
      result.ex = ex
4237 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4238 
    result.write(oprot)
4239 
    oprot.writeMessageEnd()
4240 
    oprot.trans.flush()
4241 
 
4242 
  def process_getTransaction(self, seqid, iprot, oprot):
4243 
    args = getTransaction_args()
4244 
    args.read(iprot)
4245 
    iprot.readMessageEnd()
4246 
    result = getTransaction_result()
4247 
    try:
4248 
      result.success = self._handler.getTransaction(args.id)
4249 
    except TransactionServiceException, ex:
4250 
      result.ex = ex
4251 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4252 
    result.write(oprot)
4253 
    oprot.writeMessageEnd()
4254 
    oprot.trans.flush()
4255 
 
4256 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4257 
    args = getTransactionsForCustomer_args()
4258 
    args.read(iprot)
4259 
    iprot.readMessageEnd()
4260 
    result = getTransactionsForCustomer_result()
4261 
    try:
4262 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4263 
    except TransactionServiceException, ex:
4264 
      result.ex = ex
4265 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4266 
    result.write(oprot)
4267 
    oprot.writeMessageEnd()
4268 
    oprot.trans.flush()
4269 
 
132 ashish 4270 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4271 
    args = getTransactionsForShoppingCartId_args()
4272 
    args.read(iprot)
4273 
    iprot.readMessageEnd()
4274 
    result = getTransactionsForShoppingCartId_result()
4275 
    try:
4276 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4277 
    except TransactionServiceException, ex:
4278 
      result.ex = ex
4279 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4280 
    result.write(oprot)
4281 
    oprot.writeMessageEnd()
4282 
    oprot.trans.flush()
4283 
 
94 ashish 4284 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4285 
    args = getTransactionStatus_args()
4286 
    args.read(iprot)
4287 
    iprot.readMessageEnd()
4288 
    result = getTransactionStatus_result()
4289 
    try:
4290 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4291 
    except TransactionServiceException, ex:
4292 
      result.ex = ex
4293 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4294 
    result.write(oprot)
4295 
    oprot.writeMessageEnd()
4296 
    oprot.trans.flush()
4297 
 
4298 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4299 
    args = changeTransactionStatus_args()
4300 
    args.read(iprot)
4301 
    iprot.readMessageEnd()
4302 
    result = changeTransactionStatus_result()
4303 
    try:
4304 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4305 
    except TransactionServiceException, ex:
4306 
      result.ex = ex
4307 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4308 
    result.write(oprot)
4309 
    oprot.writeMessageEnd()
4310 
    oprot.trans.flush()
4311 
 
1398 varun.gupt 4312 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4313 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4314 
    args.read(iprot)
4315 
    iprot.readMessageEnd()
1398 varun.gupt 4316 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4317 
    try:
1398 varun.gupt 4318 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4319 
    except TransactionServiceException, ex:
4320 
      result.ex = ex
1398 varun.gupt 4321 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4322 
    result.write(oprot)
4323 
    oprot.writeMessageEnd()
4324 
    oprot.trans.flush()
4325 
 
483 rajveer 4326 
  def process_getAllOrders(self, seqid, iprot, oprot):
4327 
    args = getAllOrders_args()
94 ashish 4328 
    args.read(iprot)
4329 
    iprot.readMessageEnd()
483 rajveer 4330 
    result = getAllOrders_result()
94 ashish 4331 
    try:
483 rajveer 4332 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4333 
    except TransactionServiceException, ex:
4334 
      result.ex = ex
483 rajveer 4335 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4336 
    result.write(oprot)
4337 
    oprot.writeMessageEnd()
4338 
    oprot.trans.flush()
4339 
 
4133 chandransh 4340 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4341 
    args = getOrdersInBatch_args()
4342 
    args.read(iprot)
4343 
    iprot.readMessageEnd()
4344 
    result = getOrdersInBatch_result()
4345 
    try:
4346 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4347 
    except TransactionServiceException, ex:
4348 
      result.ex = ex
4349 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4350 
    result.write(oprot)
4351 
    oprot.writeMessageEnd()
4352 
    oprot.trans.flush()
4353 
 
4354 
  def process_getOrderCount(self, seqid, iprot, oprot):
4355 
    args = getOrderCount_args()
4356 
    args.read(iprot)
4357 
    iprot.readMessageEnd()
4358 
    result = getOrderCount_result()
4359 
    try:
4360 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4361 
    except TransactionServiceException, ex:
4362 
      result.ex = ex
4363 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4364 
    result.write(oprot)
4365 
    oprot.writeMessageEnd()
4366 
    oprot.trans.flush()
4367 
 
999 varun.gupt 4368 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4369 
    args = getOrdersByBillingDate_args()
4370 
    args.read(iprot)
4371 
    iprot.readMessageEnd()
4372 
    result = getOrdersByBillingDate_result()
4373 
    try:
4374 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4375 
    except TransactionServiceException, ex:
4376 
      result.ex = ex
4377 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4378 
    result.write(oprot)
4379 
    oprot.writeMessageEnd()
4380 
    oprot.trans.flush()
4381 
 
3427 chandransh 4382 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4383 
    args = getOrdersByShippingDate_args()
4384 
    args.read(iprot)
4385 
    iprot.readMessageEnd()
4386 
    result = getOrdersByShippingDate_result()
4387 
    try:
3451 chandransh 4388 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4389 
    except TransactionServiceException, ex:
4390 
      result.ex = ex
4391 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
4395 
 
1382 varun.gupt 4396 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4397 
    args = getReturnableOrdersForCustomer_args()
4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
4400 
    result = getReturnableOrdersForCustomer_result()
4401 
    try:
4402 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4403 
    except TransactionServiceException, ex:
4404 
      result.ex = ex
4405 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
4409 
 
4410 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4411 
    args = getCancellableOrdersForCustomer_args()
4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
4414 
    result = getCancellableOrdersForCustomer_result()
4415 
    try:
4416 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4417 
    except TransactionServiceException, ex:
4418 
      result.ex = ex
4419 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4420 
    result.write(oprot)
4421 
    oprot.writeMessageEnd()
4422 
    oprot.trans.flush()
4423 
 
483 rajveer 4424 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4425 
    args = changeOrderStatus_args()
94 ashish 4426 
    args.read(iprot)
4427 
    iprot.readMessageEnd()
483 rajveer 4428 
    result = changeOrderStatus_result()
94 ashish 4429 
    try:
483 rajveer 4430 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4431 
    except TransactionServiceException, ex:
4432 
      result.ex = ex
483 rajveer 4433 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4434 
    result.write(oprot)
4435 
    oprot.writeMessageEnd()
4436 
    oprot.trans.flush()
4437 
 
483 rajveer 4438 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4439 
    args = getOrdersForTransaction_args()
94 ashish 4440 
    args.read(iprot)
4441 
    iprot.readMessageEnd()
483 rajveer 4442 
    result = getOrdersForTransaction_result()
94 ashish 4443 
    try:
1528 ankur.sing 4444 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4445 
    except TransactionServiceException, ex:
4446 
      result.ex = ex
483 rajveer 4447 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4448 
    result.write(oprot)
4449 
    oprot.writeMessageEnd()
4450 
    oprot.trans.flush()
4451 
 
483 rajveer 4452 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4453 
    args = getOrdersForCustomer_args()
94 ashish 4454 
    args.read(iprot)
4455 
    iprot.readMessageEnd()
483 rajveer 4456 
    result = getOrdersForCustomer_result()
94 ashish 4457 
    try:
3014 chandransh 4458 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4459 
    except TransactionServiceException, ex:
4460 
      result.ex = ex
483 rajveer 4461 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
4465 
 
483 rajveer 4466 
  def process_createOrder(self, seqid, iprot, oprot):
4467 
    args = createOrder_args()
94 ashish 4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
483 rajveer 4470 
    result = createOrder_result()
94 ashish 4471 
    try:
483 rajveer 4472 
      result.success = self._handler.createOrder(args.order)
94 ashish 4473 
    except TransactionServiceException, ex:
4474 
      result.ex = ex
483 rajveer 4475 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4476 
    result.write(oprot)
4477 
    oprot.writeMessageEnd()
4478 
    oprot.trans.flush()
4479 
 
483 rajveer 4480 
  def process_getOrder(self, seqid, iprot, oprot):
4481 
    args = getOrder_args()
94 ashish 4482 
    args.read(iprot)
4483 
    iprot.readMessageEnd()
483 rajveer 4484 
    result = getOrder_result()
94 ashish 4485 
    try:
483 rajveer 4486 
      result.success = self._handler.getOrder(args.id)
94 ashish 4487 
    except TransactionServiceException, ex:
4488 
      result.ex = ex
483 rajveer 4489 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4490 
    result.write(oprot)
4491 
    oprot.writeMessageEnd()
4492 
    oprot.trans.flush()
4493 
 
483 rajveer 4494 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4495 
    args = getLineItemsForOrder_args()
94 ashish 4496 
    args.read(iprot)
4497 
    iprot.readMessageEnd()
483 rajveer 4498 
    result = getLineItemsForOrder_result()
94 ashish 4499 
    try:
483 rajveer 4500 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4501 
    except TransactionServiceException, ex:
4502 
      result.ex = ex
483 rajveer 4503 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4504 
    result.write(oprot)
4505 
    oprot.writeMessageEnd()
4506 
    oprot.trans.flush()
4507 
 
1528 ankur.sing 4508 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4509 
    args = getOrderForCustomer_args()
4510 
    args.read(iprot)
4511 
    iprot.readMessageEnd()
4512 
    result = getOrderForCustomer_result()
4513 
    try:
4514 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4515 
    except TransactionServiceException, ex:
4516 
      result.ex = ex
4517 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4518 
    result.write(oprot)
4519 
    oprot.writeMessageEnd()
4520 
    oprot.trans.flush()
4521 
 
3064 chandransh 4522 
  def process_getAlerts(self, seqid, iprot, oprot):
4523 
    args = getAlerts_args()
4524 
    args.read(iprot)
4525 
    iprot.readMessageEnd()
4526 
    result = getAlerts_result()
4444 rajveer 4527 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4528 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4529 
    result.write(oprot)
4530 
    oprot.writeMessageEnd()
4531 
    oprot.trans.flush()
4532 
 
4394 rajveer 4533 
  def process_addAlert(self, seqid, iprot, oprot):
4534 
    args = addAlert_args()
3064 chandransh 4535 
    args.read(iprot)
4536 
    iprot.readMessageEnd()
4394 rajveer 4537 
    result = addAlert_result()
4444 rajveer 4538 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4539 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
4444 rajveer 4544 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4545 
    args = markAlertsAsSeen_args()
4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
4548 
    result = markAlertsAsSeen_result()
4549 
    self._handler.markAlertsAsSeen(args.warehouseId)
4550 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4554 
 
3064 chandransh 4555 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4556 
    args = getValidOrderCount_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = getValidOrderCount_result()
4560 
    result.success = self._handler.getValidOrderCount()
4561 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
4565 
 
4566 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4567 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4571 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4572 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4573 
    result.write(oprot)
4574 
    oprot.writeMessageEnd()
4575 
    oprot.trans.flush()
4576 
 
4577 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4578 
    args = getValidOrdersAmountRange_args()
4579 
    args.read(iprot)
4580 
    iprot.readMessageEnd()
4581 
    result = getValidOrdersAmountRange_result()
4582 
    result.success = self._handler.getValidOrdersAmountRange()
4583 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4584 
    result.write(oprot)
4585 
    oprot.writeMessageEnd()
4586 
    oprot.trans.flush()
4587 
 
4588 
  def process_getValidOrders(self, seqid, iprot, oprot):
4589 
    args = getValidOrders_args()
4590 
    args.read(iprot)
4591 
    iprot.readMessageEnd()
4592 
    result = getValidOrders_result()
4593 
    result.success = self._handler.getValidOrders(args.limit)
4594 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4595 
    result.write(oprot)
4596 
    oprot.writeMessageEnd()
4597 
    oprot.trans.flush()
4598 
 
1220 chandransh 4599 
  def process_batchOrders(self, seqid, iprot, oprot):
4600 
    args = batchOrders_args()
4601 
    args.read(iprot)
4602 
    iprot.readMessageEnd()
4603 
    result = batchOrders_result()
4604 
    try:
4605 
      result.success = self._handler.batchOrders(args.warehouseId)
4606 
    except TransactionServiceException, ex:
4607 
      result.ex = ex
4608 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
1208 chandransh 4613 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4614 
    args = markOrderAsOutOfStock_args()
4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
4617 
    result = markOrderAsOutOfStock_result()
4618 
    try:
4619 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4620 
    except TransactionServiceException, ex:
4621 
      result.ex = ex
4622 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4623 
    result.write(oprot)
4624 
    oprot.writeMessageEnd()
4625 
    oprot.trans.flush()
4626 
 
3064 chandransh 4627 
  def process_verifyOrder(self, seqid, iprot, oprot):
4628 
    args = verifyOrder_args()
759 chandransh 4629 
    args.read(iprot)
4630 
    iprot.readMessageEnd()
3064 chandransh 4631 
    result = verifyOrder_result()
759 chandransh 4632 
    try:
3064 chandransh 4633 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4634 
    except TransactionServiceException, ex:
4635 
      result.ex = ex
3064 chandransh 4636 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4637 
    result.write(oprot)
4638 
    oprot.writeMessageEnd()
4639 
    oprot.trans.flush()
4640 
 
3064 chandransh 4641 
  def process_acceptOrder(self, seqid, iprot, oprot):
4642 
    args = acceptOrder_args()
1113 chandransh 4643 
    args.read(iprot)
4644 
    iprot.readMessageEnd()
3064 chandransh 4645 
    result = acceptOrder_result()
1113 chandransh 4646 
    try:
3064 chandransh 4647 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4648 
    except TransactionServiceException, ex:
4649 
      result.ex = ex
3064 chandransh 4650 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
3064 chandransh 4655 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4656 
    args = addBillingDetails_args()
1135 chandransh 4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
3064 chandransh 4659 
    result = addBillingDetails_result()
1135 chandransh 4660 
    try:
4283 anupam.sin 4661 
      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 4662 
    except TransactionServiceException, ex:
4663 
      result.ex = ex
3064 chandransh 4664 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4665 
    result.write(oprot)
4666 
    oprot.writeMessageEnd()
4667 
    oprot.trans.flush()
4668 
 
4579 rajveer 4669 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4670 
    args = addInvoiceNumber_args()
4671 
    args.read(iprot)
4672 
    iprot.readMessageEnd()
4673 
    result = addInvoiceNumber_result()
4674 
    try:
4675 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4676 
    except TransactionServiceException, ex:
4677 
      result.ex = ex
4678 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4679 
    result.write(oprot)
4680 
    oprot.writeMessageEnd()
4681 
    oprot.trans.flush()
4682 
 
3064 chandransh 4683 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4684 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4685 
    args.read(iprot)
4686 
    iprot.readMessageEnd()
3064 chandransh 4687 
    result = markOrdersAsManifested_result()
4688 
    try:
4689 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4690 
    except TransactionServiceException, ex:
4691 
      result.ex = ex
4692 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4693 
    result.write(oprot)
4694 
    oprot.writeMessageEnd()
4695 
    oprot.trans.flush()
4696 
 
4410 rajveer 4697 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4698 
    args = markOrdersAsShippedFromWarehouse_args()
4699 
    args.read(iprot)
4700 
    iprot.readMessageEnd()
4701 
    result = markOrdersAsShippedFromWarehouse_result()
4702 
    try:
4703 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4704 
    except TransactionServiceException, ex:
4705 
      result.ex = ex
4706 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4707 
    result.write(oprot)
4708 
    oprot.writeMessageEnd()
4709 
    oprot.trans.flush()
4710 
 
3064 chandransh 4711 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4712 
    args = markOrdersAsPickedUp_args()
304 ashish 4713 
    args.read(iprot)
4714 
    iprot.readMessageEnd()
3064 chandransh 4715 
    result = markOrdersAsPickedUp_result()
4716 
    try:
4717 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4718 
    except TransactionServiceException, ex:
4719 
      result.ex = ex
4720 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4721 
    result.write(oprot)
4722 
    oprot.writeMessageEnd()
4723 
    oprot.trans.flush()
94 ashish 4724 
 
3064 chandransh 4725 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4726 
    args = markOrdersAsDelivered_args()
304 ashish 4727 
    args.read(iprot)
4728 
    iprot.readMessageEnd()
3064 chandransh 4729 
    result = markOrdersAsDelivered_result()
4730 
    try:
4731 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4732 
    except TransactionServiceException, ex:
4733 
      result.ex = ex
4734 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4735 
    result.write(oprot)
4736 
    oprot.writeMessageEnd()
4737 
    oprot.trans.flush()
4738 
 
3064 chandransh 4739 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4740 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4741 
    args.read(iprot)
4742 
    iprot.readMessageEnd()
3064 chandransh 4743 
    result = markOrdersAsFailed_result()
4744 
    try:
4745 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4746 
    except TransactionServiceException, ex:
4747 
      result.ex = ex
4748 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
304 ashish 4752 
 
3064 chandransh 4753 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4754 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
3064 chandransh 4757 
    result = updateNonDeliveryReason_result()
4758 
    try:
4581 phani.kuma 4759 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4760 
    except TransactionServiceException, ex:
4761 
      result.ex = ex
4762 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4763 
    result.write(oprot)
4764 
    oprot.writeMessageEnd()
4765 
    oprot.trans.flush()
1596 ankur.sing 4766 
 
3064 chandransh 4767 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4768 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4769 
    args.read(iprot)
4770 
    iprot.readMessageEnd()
3064 chandransh 4771 
    result = getUndeliveredOrders_result()
4772 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4773 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4777 
 
2536 chandransh 4778 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4779 
    args = toggleDOAFlag_args()
4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
4782 
    result = toggleDOAFlag_result()
4783 
    try:
4784 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4785 
    except TransactionServiceException, ex:
4786 
      result.ex = ex
4787 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
1886 ankur.sing 4791 
 
4454 rajveer 4792 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4793 
    args = markOrderDoaRequestReceived_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = markOrderDoaRequestReceived_result()
4797 
    try:
4798 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4799 
    except TransactionServiceException, ex:
4800 
      result.ex = ex
4801 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
4806 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4807 
    args = markOrderDoaRequestAuthorized_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = markOrderDoaRequestAuthorized_result()
4811 
    try:
4812 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4813 
    except TransactionServiceException, ex:
4814 
      result.ex = ex
4815 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
4819 
 
4488 rajveer 4820 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4821 
    args = markOrderReturnRequestReceived_args()
4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
4824 
    result = markOrderReturnRequestReceived_result()
4825 
    try:
4826 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4827 
    except TransactionServiceException, ex:
4828 
      result.ex = ex
4829 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4833 
 
4834 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4835 
    args = markOrderReturnRequestAuthorized_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = markOrderReturnRequestAuthorized_result()
4839 
    try:
4840 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4841 
    except TransactionServiceException, ex:
4842 
      result.ex = ex
4843 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4844 
    result.write(oprot)
4845 
    oprot.writeMessageEnd()
4846 
    oprot.trans.flush()
4847 
 
2536 chandransh 4848 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4849 
    args = requestPickupNumber_args()
4850 
    args.read(iprot)
4851 
    iprot.readMessageEnd()
4852 
    result = requestPickupNumber_result()
4853 
    try:
4579 rajveer 4854 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4855 
    except TransactionServiceException, ex:
4856 
      result.ex = ex
4857 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4858 
    result.write(oprot)
4859 
    oprot.writeMessageEnd()
4860 
    oprot.trans.flush()
4861 
 
4862 
  def process_authorizePickup(self, seqid, iprot, oprot):
4863 
    args = authorizePickup_args()
4864 
    args.read(iprot)
4865 
    iprot.readMessageEnd()
4866 
    result = authorizePickup_result()
4867 
    try:
4602 rajveer 4868 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 4869 
    except TransactionServiceException, ex:
4870 
      result.ex = ex
4871 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
2764 chandransh 4876 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4877 
    args = markDoasAsPickedUp_args()
4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
4880 
    result = markDoasAsPickedUp_result()
4881 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4882 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4883 
    result.write(oprot)
4884 
    oprot.writeMessageEnd()
4885 
    oprot.trans.flush()
4886 
 
2616 chandransh 4887 
  def process_receiveReturn(self, seqid, iprot, oprot):
4888 
    args = receiveReturn_args()
2591 chandransh 4889 
    args.read(iprot)
4890 
    iprot.readMessageEnd()
2616 chandransh 4891 
    result = receiveReturn_result()
2591 chandransh 4892 
    try:
4479 rajveer 4893 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4894 
    except TransactionServiceException, ex:
4895 
      result.ex = ex
2616 chandransh 4896 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4897 
    result.write(oprot)
4898 
    oprot.writeMessageEnd()
4899 
    oprot.trans.flush()
2536 chandransh 4900 
 
2591 chandransh 4901 
  def process_validateDoa(self, seqid, iprot, oprot):
4902 
    args = validateDoa_args()
4903 
    args.read(iprot)
4904 
    iprot.readMessageEnd()
4905 
    result = validateDoa_result()
4906 
    try:
4907 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4908 
    except TransactionServiceException, ex:
4909 
      result.ex = ex
4910 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4911 
    result.write(oprot)
4912 
    oprot.writeMessageEnd()
4913 
    oprot.trans.flush()
4914 
 
4495 rajveer 4915 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4916 
    args = validateReturnProduct_args()
4917 
    args.read(iprot)
4918 
    iprot.readMessageEnd()
4919 
    result = validateReturnProduct_result()
4920 
    try:
4921 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4922 
    except TransactionServiceException, ex:
4923 
      result.ex = ex
4924 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4928 
 
2616 chandransh 4929 
  def process_reshipOrder(self, seqid, iprot, oprot):
4930 
    args = reshipOrder_args()
4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
4933 
    result = reshipOrder_result()
4934 
    try:
4935 
      result.success = self._handler.reshipOrder(args.orderId)
4936 
    except TransactionServiceException, ex:
4937 
      result.ex = ex
4938 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
2591 chandransh 4942 
 
2616 chandransh 4943 
  def process_refundOrder(self, seqid, iprot, oprot):
4944 
    args = refundOrder_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = refundOrder_result()
4948 
    try:
3226 chandransh 4949 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4950 
    except TransactionServiceException, ex:
4951 
      result.ex = ex
4952 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
4956 
 
2690 chandransh 4957 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4958 
    args = getReturnOrders_args()
4959 
    args.read(iprot)
4960 
    iprot.readMessageEnd()
4961 
    result = getReturnOrders_result()
4962 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4963 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4964 
    result.write(oprot)
4965 
    oprot.writeMessageEnd()
4966 
    oprot.trans.flush()
2616 chandransh 4967 
 
2700 chandransh 4968 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4969 
    args = getReturnOrder_args()
4970 
    args.read(iprot)
4971 
    iprot.readMessageEnd()
4972 
    result = getReturnOrder_result()
4973 
    try:
4974 
      result.success = self._handler.getReturnOrder(args.id)
4975 
    except TransactionServiceException, ex:
4976 
      result.ex = ex
4977 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4978 
    result.write(oprot)
4979 
    oprot.writeMessageEnd()
4980 
    oprot.trans.flush()
4981 
 
2690 chandransh 4982 
  def process_processReturn(self, seqid, iprot, oprot):
4983 
    args = processReturn_args()
4984 
    args.read(iprot)
4985 
    iprot.readMessageEnd()
4986 
    result = processReturn_result()
4987 
    try:
4988 
      self._handler.processReturn(args.returnOrderId)
4989 
    except TransactionServiceException, ex:
4990 
      result.ex = ex
4991 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
2819 chandransh 4996 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4997 
    args = createPurchaseOrder_args()
4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
5000 
    result = createPurchaseOrder_result()
5001 
    try:
5002 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5003 
    except TransactionServiceException, ex:
5004 
      result.ex = ex
5005 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5006 
    result.write(oprot)
5007 
    oprot.writeMessageEnd()
5008 
    oprot.trans.flush()
2690 chandransh 5009 
 
3451 chandransh 5010 
  def process_updateWeight(self, seqid, iprot, oprot):
5011 
    args = updateWeight_args()
5012 
    args.read(iprot)
5013 
    iprot.readMessageEnd()
5014 
    result = updateWeight_result()
5015 
    try:
5016 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5017 
    except TransactionServiceException, ex:
5018 
      result.ex = ex
5019 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5020 
    result.write(oprot)
5021 
    oprot.writeMessageEnd()
5022 
    oprot.trans.flush()
2819 chandransh 5023 
 
3469 chandransh 5024 
  def process_changeItem(self, seqid, iprot, oprot):
5025 
    args = changeItem_args()
5026 
    args.read(iprot)
5027 
    iprot.readMessageEnd()
5028 
    result = changeItem_result()
5029 
    try:
5030 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5031 
    except TransactionServiceException, ex:
5032 
      result.ex = ex
5033 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5034 
    result.write(oprot)
5035 
    oprot.writeMessageEnd()
5036 
    oprot.trans.flush()
3451 chandransh 5037 
 
3469 chandransh 5038 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5039 
    args = shiftToWarehouse_args()
5040 
    args.read(iprot)
5041 
    iprot.readMessageEnd()
5042 
    result = shiftToWarehouse_result()
5043 
    try:
5044 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5045 
    except TransactionServiceException, ex:
5046 
      result.ex = ex
5047 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5048 
    result.write(oprot)
5049 
    oprot.writeMessageEnd()
5050 
    oprot.trans.flush()
5051 
 
3553 chandransh 5052 
  def process_addDelayReason(self, seqid, iprot, oprot):
5053 
    args = addDelayReason_args()
5054 
    args.read(iprot)
5055 
    iprot.readMessageEnd()
5056 
    result = addDelayReason_result()
5057 
    try:
3986 chandransh 5058 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 5059 
    except TransactionServiceException, ex:
5060 
      result.ex = ex
5061 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5062 
    result.write(oprot)
5063 
    oprot.writeMessageEnd()
5064 
    oprot.trans.flush()
3469 chandransh 5065 
 
3956 chandransh 5066 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5067 
    args = reconcileCodCollection_args()
5068 
    args.read(iprot)
5069 
    iprot.readMessageEnd()
5070 
    result = reconcileCodCollection_result()
5071 
    try:
5072 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5073 
    except TransactionServiceException, ex:
5074 
      result.ex = ex
5075 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
3553 chandransh 5079 
 
4008 mandeep.dh 5080 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5081 
    args = getTransactionsRequiringExtraProcessing_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = getTransactionsRequiringExtraProcessing_result()
5085 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5086 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
3956 chandransh 5090 
 
4008 mandeep.dh 5091 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5092 
    args = markTransactionAsProcessed_args()
5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
5095 
    result = markTransactionAsProcessed_result()
5096 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5097 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
5101 
 
4018 chandransh 5102 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5103 
    args = getItemWiseRiskyOrdersCount_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = getItemWiseRiskyOrdersCount_result()
5107 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5108 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5109 
    result.write(oprot)
5110 
    oprot.writeMessageEnd()
5111 
    oprot.trans.flush()
4008 mandeep.dh 5112 
 
4295 varun.gupt 5113 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5114 
    args = getOrdersForItemIds_args()
5115 
    args.read(iprot)
5116 
    iprot.readMessageEnd()
5117 
    result = getOrdersForItemIds_result()
5118 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5119 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5120 
    result.write(oprot)
5121 
    oprot.writeMessageEnd()
5122 
    oprot.trans.flush()
5123 
 
4247 rajveer 5124 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5125 
    args = markOrderCancellationRequestReceived_args()
5126 
    args.read(iprot)
5127 
    iprot.readMessageEnd()
5128 
    result = markOrderCancellationRequestReceived_result()
5129 
    try:
5130 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5131 
    except TransactionServiceException, ex:
5132 
      result.ex = ex
5133 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
4018 chandransh 5137 
 
4247 rajveer 5138 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5139 
    args = markOrderCancellationRequestConfirmed_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = markOrderCancellationRequestConfirmed_result()
5143 
    try:
5144 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5145 
    except TransactionServiceException, ex:
5146 
      result.ex = ex
5147 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
5152 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5153 
    args = markOrderCancellationRequestDenied_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = markOrderCancellationRequestDenied_result()
5157 
    try:
5158 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5159 
    except TransactionServiceException, ex:
5160 
      result.ex = ex
5161 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
4258 rajveer 5166 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5167 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
4258 rajveer 5170 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5171 
    try:
4258 rajveer 5172 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5173 
    except TransactionServiceException, ex:
5174 
      result.ex = ex
4258 rajveer 5175 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
4259 anupam.sin 5180 
  def process_refundTransaction(self, seqid, iprot, oprot):
5181 
    args = refundTransaction_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = refundTransaction_result()
5185 
    try:
5186 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5187 
    except TransactionServiceException, ex:
5188 
      result.ex = ex
5189 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
4247 rajveer 5193 
 
4324 mandeep.dh 5194 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5195 
    args = updateShipmentAddress_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = updateShipmentAddress_result()
5199 
    try:
5200 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5201 
    except TransactionServiceException, ex:
5202 
      result.ex = ex
5203 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5204 
    result.write(oprot)
5205 
    oprot.writeMessageEnd()
5206 
    oprot.trans.flush()
5207 
 
4285 rajveer 5208 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5209 
    args = acceptOrdersForItemId_args()
5210 
    args.read(iprot)
5211 
    iprot.readMessageEnd()
5212 
    result = acceptOrdersForItemId_result()
5213 
    try:
5214 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5215 
    except TransactionServiceException, ex:
5216 
      result.ex = ex
5217 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5218 
    result.write(oprot)
5219 
    oprot.writeMessageEnd()
5220 
    oprot.trans.flush()
4259 anupam.sin 5221 
 
4303 rajveer 5222 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5223 
    args = markOrdersAsPORaised_args()
5224 
    args.read(iprot)
5225 
    iprot.readMessageEnd()
5226 
    result = markOrdersAsPORaised_result()
5227 
    try:
4369 rajveer 5228 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5229 
    except TransactionServiceException, ex:
5230 
      result.ex = ex
5231 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5232 
    result.write(oprot)
5233 
    oprot.writeMessageEnd()
5234 
    oprot.trans.flush()
4285 rajveer 5235 
 
4303 rajveer 5236 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5237 
    args = markOrdersAsReversalInitiated_args()
5238 
    args.read(iprot)
5239 
    iprot.readMessageEnd()
5240 
    result = markOrdersAsReversalInitiated_result()
5241 
    try:
4369 rajveer 5242 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5243 
    except TransactionServiceException, ex:
5244 
      result.ex = ex
5245 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5246 
    result.write(oprot)
5247 
    oprot.writeMessageEnd()
5248 
    oprot.trans.flush()
5249 
 
5250 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5251 
    args = markOrdersAsNotAvailabke_args()
5252 
    args.read(iprot)
5253 
    iprot.readMessageEnd()
5254 
    result = markOrdersAsNotAvailabke_result()
5255 
    try:
4369 rajveer 5256 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5257 
    except TransactionServiceException, ex:
5258 
      result.ex = ex
5259 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
5263 
 
4369 rajveer 5264 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5265 
    args = markOrdersAsTimeout_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = markOrdersAsTimeout_result()
5269 
    try:
5270 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5271 
    except TransactionServiceException, ex:
5272 
      result.ex = ex
5273 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5274 
    result.write(oprot)
5275 
    oprot.writeMessageEnd()
5276 
    oprot.trans.flush()
4303 rajveer 5277 
 
4386 anupam.sin 5278 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5279 
    args = getOrderForAwb_args()
5280 
    args.read(iprot)
5281 
    iprot.readMessageEnd()
5282 
    result = getOrderForAwb_result()
5283 
    try:
5284 
      result.success = self._handler.getOrderForAwb(args.awb)
5285 
    except TransactionServiceException, ex:
5286 
      result.ex = ex
5287 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
4369 rajveer 5291 
 
4506 phani.kuma 5292 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5293 
    args = getOrdersForProviderForStatus_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getOrdersForProviderForStatus_result()
5297 
    try:
5298 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5299 
    except TransactionServiceException, ex:
5300 
      result.ex = ex
5301 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5302 
    result.write(oprot)
5303 
    oprot.writeMessageEnd()
5304 
    oprot.trans.flush()
4386 anupam.sin 5305 
 
4600 varun.gupt 5306 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5307 
    args = getBilledOrdersForVendor_args()
5308 
    args.read(iprot)
5309 
    iprot.readMessageEnd()
5310 
    result = getBilledOrdersForVendor_result()
5311 
    try:
5312 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5313 
    except TransactionServiceException, ex:
5314 
      result.ex = ex
5315 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5316 
    result.write(oprot)
5317 
    oprot.writeMessageEnd()
5318 
    oprot.trans.flush()
4506 phani.kuma 5319 
 
4600 varun.gupt 5320 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5321 
    args = saveBluedartSettlements_args()
5322 
    args.read(iprot)
5323 
    iprot.readMessageEnd()
5324 
    result = saveBluedartSettlements_result()
5325 
    try:
5326 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5327 
    except TransactionServiceException, ex:
5328 
      result.ex = ex
5329 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5330 
    result.write(oprot)
5331 
    oprot.writeMessageEnd()
5332 
    oprot.trans.flush()
5333 
 
5334 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5335 
    args = savePaymentSettlements_args()
5336 
    args.read(iprot)
5337 
    iprot.readMessageEnd()
5338 
    result = savePaymentSettlements_result()
5339 
    try:
5340 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5341 
    except TransactionServiceException, ex:
5342 
      result.ex = ex
5343 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5344 
    result.write(oprot)
5345 
    oprot.writeMessageEnd()
5346 
    oprot.trans.flush()
5347 
 
5348 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5349 
    args = saveEBSSettlementSummary_args()
5350 
    args.read(iprot)
5351 
    iprot.readMessageEnd()
5352 
    result = saveEBSSettlementSummary_result()
5353 
    try:
5354 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5355 
    except TransactionServiceException, ex:
5356 
      result.ex = ex
5357 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5358 
    result.write(oprot)
5359 
    oprot.writeMessageEnd()
5360 
    oprot.trans.flush()
5361 
 
5362 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5363 
    args = getSettlementForPaymentId_args()
5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
5366 
    result = getSettlementForPaymentId_result()
5367 
    try:
5368 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5369 
    except TransactionServiceException, ex:
5370 
      result.ex = ex
5371 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5372 
    result.write(oprot)
5373 
    oprot.writeMessageEnd()
5374 
    oprot.trans.flush()
5375 
 
5376 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5377 
    args = getEBSSettlementSummaries_args()
5378 
    args.read(iprot)
5379 
    iprot.readMessageEnd()
5380 
    result = getEBSSettlementSummaries_result()
5381 
    try:
5382 
      result.success = self._handler.getEBSSettlementSummaries()
5383 
    except TransactionServiceException, ex:
5384 
      result.ex = ex
5385 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5386 
    result.write(oprot)
5387 
    oprot.writeMessageEnd()
5388 
    oprot.trans.flush()
5389 
 
5390 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5391 
    args = markEBSSettlementUploaded_args()
5392 
    args.read(iprot)
5393 
    iprot.readMessageEnd()
5394 
    result = markEBSSettlementUploaded_result()
5395 
    try:
5396 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5397 
    except TransactionServiceException, ex:
5398 
      result.ex = ex
5399 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5400 
    result.write(oprot)
5401 
    oprot.writeMessageEnd()
5402 
    oprot.trans.flush()
5403 
 
5404 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5405 
    args = getEBSSettlementDate_args()
5406 
    args.read(iprot)
5407 
    iprot.readMessageEnd()
5408 
    result = getEBSSettlementDate_result()
5409 
    try:
5410 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5411 
    except TransactionServiceException, ex:
5412 
      result.ex = ex
5413 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5414 
    result.write(oprot)
5415 
    oprot.writeMessageEnd()
5416 
    oprot.trans.flush()
5417 
 
5418 
 
94 ashish 5419 
# HELPER FUNCTIONS AND STRUCTURES
5420 
 
5421 
class createTransaction_args:
5422 
  """
5423 
  Attributes:
5424 
   - transaction
5425 
  """
5426 
 
5427 
  thrift_spec = (
5428 
    None, # 0
5429 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5430 
  )
5431 
 
5432 
  def __init__(self, transaction=None,):
5433 
    self.transaction = transaction
5434 
 
5435 
  def read(self, iprot):
5436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5438 
      return
5439 
    iprot.readStructBegin()
5440 
    while True:
5441 
      (fname, ftype, fid) = iprot.readFieldBegin()
5442 
      if ftype == TType.STOP:
5443 
        break
5444 
      if fid == 1:
5445 
        if ftype == TType.STRUCT:
5446 
          self.transaction = Transaction()
5447 
          self.transaction.read(iprot)
5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      else:
5451 
        iprot.skip(ftype)
5452 
      iprot.readFieldEnd()
5453 
    iprot.readStructEnd()
5454 
 
5455 
  def write(self, oprot):
5456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5458 
      return
5459 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5460 
    if self.transaction is not None:
94 ashish 5461 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5462 
      self.transaction.write(oprot)
5463 
      oprot.writeFieldEnd()
5464 
    oprot.writeFieldStop()
5465 
    oprot.writeStructEnd()
5466 
 
3431 rajveer 5467 
  def validate(self):
5468 
    return
5469 
 
5470 
 
94 ashish 5471 
  def __repr__(self):
5472 
    L = ['%s=%r' % (key, value)
5473 
      for key, value in self.__dict__.iteritems()]
5474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5475 
 
5476 
  def __eq__(self, other):
5477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5478 
 
5479 
  def __ne__(self, other):
5480 
    return not (self == other)
5481 
 
5482 
class createTransaction_result:
5483 
  """
5484 
  Attributes:
132 ashish 5485 
   - success
94 ashish 5486 
   - ex
5487 
  """
5488 
 
5489 
  thrift_spec = (
132 ashish 5490 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5492 
  )
5493 
 
132 ashish 5494 
  def __init__(self, success=None, ex=None,):
5495 
    self.success = success
94 ashish 5496 
    self.ex = ex
5497 
 
5498 
  def read(self, iprot):
5499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5501 
      return
5502 
    iprot.readStructBegin()
5503 
    while True:
5504 
      (fname, ftype, fid) = iprot.readFieldBegin()
5505 
      if ftype == TType.STOP:
5506 
        break
132 ashish 5507 
      if fid == 0:
5508 
        if ftype == TType.I64:
5509 
          self.success = iprot.readI64();
5510 
        else:
5511 
          iprot.skip(ftype)
5512 
      elif fid == 1:
94 ashish 5513 
        if ftype == TType.STRUCT:
5514 
          self.ex = TransactionServiceException()
5515 
          self.ex.read(iprot)
5516 
        else:
5517 
          iprot.skip(ftype)
5518 
      else:
5519 
        iprot.skip(ftype)
5520 
      iprot.readFieldEnd()
5521 
    iprot.readStructEnd()
5522 
 
5523 
  def write(self, oprot):
5524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5526 
      return
5527 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5528 
    if self.success is not None:
132 ashish 5529 
      oprot.writeFieldBegin('success', TType.I64, 0)
5530 
      oprot.writeI64(self.success)
5531 
      oprot.writeFieldEnd()
3431 rajveer 5532 
    if self.ex is not None:
94 ashish 5533 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5534 
      self.ex.write(oprot)
5535 
      oprot.writeFieldEnd()
5536 
    oprot.writeFieldStop()
5537 
    oprot.writeStructEnd()
5538 
 
3431 rajveer 5539 
  def validate(self):
5540 
    return
5541 
 
5542 
 
94 ashish 5543 
  def __repr__(self):
5544 
    L = ['%s=%r' % (key, value)
5545 
      for key, value in self.__dict__.iteritems()]
5546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5547 
 
5548 
  def __eq__(self, other):
5549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5550 
 
5551 
  def __ne__(self, other):
5552 
    return not (self == other)
5553 
 
5554 
class getTransaction_args:
5555 
  """
5556 
  Attributes:
5557 
   - id
5558 
  """
5559 
 
5560 
  thrift_spec = (
5561 
    None, # 0
5562 
    (1, TType.I64, 'id', None, None, ), # 1
5563 
  )
5564 
 
5565 
  def __init__(self, id=None,):
5566 
    self.id = id
5567 
 
5568 
  def read(self, iprot):
5569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5571 
      return
5572 
    iprot.readStructBegin()
5573 
    while True:
5574 
      (fname, ftype, fid) = iprot.readFieldBegin()
5575 
      if ftype == TType.STOP:
5576 
        break
5577 
      if fid == 1:
5578 
        if ftype == TType.I64:
5579 
          self.id = iprot.readI64();
5580 
        else:
5581 
          iprot.skip(ftype)
5582 
      else:
5583 
        iprot.skip(ftype)
5584 
      iprot.readFieldEnd()
5585 
    iprot.readStructEnd()
5586 
 
5587 
  def write(self, oprot):
5588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5590 
      return
5591 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5592 
    if self.id is not None:
94 ashish 5593 
      oprot.writeFieldBegin('id', TType.I64, 1)
5594 
      oprot.writeI64(self.id)
5595 
      oprot.writeFieldEnd()
5596 
    oprot.writeFieldStop()
5597 
    oprot.writeStructEnd()
5598 
 
3431 rajveer 5599 
  def validate(self):
5600 
    return
5601 
 
5602 
 
94 ashish 5603 
  def __repr__(self):
5604 
    L = ['%s=%r' % (key, value)
5605 
      for key, value in self.__dict__.iteritems()]
5606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5607 
 
5608 
  def __eq__(self, other):
5609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5610 
 
5611 
  def __ne__(self, other):
5612 
    return not (self == other)
5613 
 
5614 
class getTransaction_result:
5615 
  """
5616 
  Attributes:
5617 
   - success
5618 
   - ex
5619 
  """
5620 
 
5621 
  thrift_spec = (
5622 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5624 
  )
5625 
 
5626 
  def __init__(self, success=None, ex=None,):
5627 
    self.success = success
5628 
    self.ex = ex
5629 
 
5630 
  def read(self, iprot):
5631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5633 
      return
5634 
    iprot.readStructBegin()
5635 
    while True:
5636 
      (fname, ftype, fid) = iprot.readFieldBegin()
5637 
      if ftype == TType.STOP:
5638 
        break
5639 
      if fid == 0:
5640 
        if ftype == TType.STRUCT:
5641 
          self.success = Transaction()
5642 
          self.success.read(iprot)
5643 
        else:
5644 
          iprot.skip(ftype)
5645 
      elif fid == 1:
5646 
        if ftype == TType.STRUCT:
5647 
          self.ex = TransactionServiceException()
5648 
          self.ex.read(iprot)
5649 
        else:
5650 
          iprot.skip(ftype)
5651 
      else:
5652 
        iprot.skip(ftype)
5653 
      iprot.readFieldEnd()
5654 
    iprot.readStructEnd()
5655 
 
5656 
  def write(self, oprot):
5657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5659 
      return
5660 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5661 
    if self.success is not None:
94 ashish 5662 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5663 
      self.success.write(oprot)
5664 
      oprot.writeFieldEnd()
3431 rajveer 5665 
    if self.ex is not None:
94 ashish 5666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5667 
      self.ex.write(oprot)
5668 
      oprot.writeFieldEnd()
5669 
    oprot.writeFieldStop()
5670 
    oprot.writeStructEnd()
5671 
 
3431 rajveer 5672 
  def validate(self):
5673 
    return
5674 
 
5675 
 
94 ashish 5676 
  def __repr__(self):
5677 
    L = ['%s=%r' % (key, value)
5678 
      for key, value in self.__dict__.iteritems()]
5679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5680 
 
5681 
  def __eq__(self, other):
5682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5683 
 
5684 
  def __ne__(self, other):
5685 
    return not (self == other)
5686 
 
5687 
class getTransactionsForCustomer_args:
5688 
  """
5689 
  Attributes:
5690 
   - customerId
5691 
   - from_date
5692 
   - to_date
5693 
   - status
5694 
  """
5695 
 
5696 
  thrift_spec = (
5697 
    None, # 0
5698 
    (1, TType.I64, 'customerId', None, None, ), # 1
5699 
    (2, TType.I64, 'from_date', None, None, ), # 2
5700 
    (3, TType.I64, 'to_date', None, None, ), # 3
5701 
    (4, TType.I32, 'status', None, None, ), # 4
5702 
  )
5703 
 
5704 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5705 
    self.customerId = customerId
5706 
    self.from_date = from_date
5707 
    self.to_date = to_date
5708 
    self.status = status
5709 
 
5710 
  def read(self, iprot):
5711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5713 
      return
5714 
    iprot.readStructBegin()
5715 
    while True:
5716 
      (fname, ftype, fid) = iprot.readFieldBegin()
5717 
      if ftype == TType.STOP:
5718 
        break
5719 
      if fid == 1:
5720 
        if ftype == TType.I64:
5721 
          self.customerId = iprot.readI64();
5722 
        else:
5723 
          iprot.skip(ftype)
5724 
      elif fid == 2:
5725 
        if ftype == TType.I64:
5726 
          self.from_date = iprot.readI64();
5727 
        else:
5728 
          iprot.skip(ftype)
5729 
      elif fid == 3:
5730 
        if ftype == TType.I64:
5731 
          self.to_date = iprot.readI64();
5732 
        else:
5733 
          iprot.skip(ftype)
5734 
      elif fid == 4:
5735 
        if ftype == TType.I32:
5736 
          self.status = iprot.readI32();
5737 
        else:
5738 
          iprot.skip(ftype)
5739 
      else:
5740 
        iprot.skip(ftype)
5741 
      iprot.readFieldEnd()
5742 
    iprot.readStructEnd()
5743 
 
5744 
  def write(self, oprot):
5745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5747 
      return
5748 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5749 
    if self.customerId is not None:
94 ashish 5750 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5751 
      oprot.writeI64(self.customerId)
5752 
      oprot.writeFieldEnd()
3431 rajveer 5753 
    if self.from_date is not None:
94 ashish 5754 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5755 
      oprot.writeI64(self.from_date)
5756 
      oprot.writeFieldEnd()
3431 rajveer 5757 
    if self.to_date is not None:
94 ashish 5758 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5759 
      oprot.writeI64(self.to_date)
5760 
      oprot.writeFieldEnd()
3431 rajveer 5761 
    if self.status is not None:
94 ashish 5762 
      oprot.writeFieldBegin('status', TType.I32, 4)
5763 
      oprot.writeI32(self.status)
5764 
      oprot.writeFieldEnd()
5765 
    oprot.writeFieldStop()
5766 
    oprot.writeStructEnd()
5767 
 
3431 rajveer 5768 
  def validate(self):
5769 
    return
5770 
 
5771 
 
94 ashish 5772 
  def __repr__(self):
5773 
    L = ['%s=%r' % (key, value)
5774 
      for key, value in self.__dict__.iteritems()]
5775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5776 
 
5777 
  def __eq__(self, other):
5778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5779 
 
5780 
  def __ne__(self, other):
5781 
    return not (self == other)
5782 
 
5783 
class getTransactionsForCustomer_result:
5784 
  """
5785 
  Attributes:
5786 
   - success
5787 
   - ex
5788 
  """
5789 
 
5790 
  thrift_spec = (
5791 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5792 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5793 
  )
5794 
 
5795 
  def __init__(self, success=None, ex=None,):
5796 
    self.success = success
5797 
    self.ex = ex
5798 
 
5799 
  def read(self, iprot):
5800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5802 
      return
5803 
    iprot.readStructBegin()
5804 
    while True:
5805 
      (fname, ftype, fid) = iprot.readFieldBegin()
5806 
      if ftype == TType.STOP:
5807 
        break
5808 
      if fid == 0:
5809 
        if ftype == TType.LIST:
5810 
          self.success = []
685 chandransh 5811 
          (_etype17, _size14) = iprot.readListBegin()
5812 
          for _i18 in xrange(_size14):
5813 
            _elem19 = Transaction()
5814 
            _elem19.read(iprot)
5815 
            self.success.append(_elem19)
94 ashish 5816 
          iprot.readListEnd()
5817 
        else:
5818 
          iprot.skip(ftype)
5819 
      elif fid == 1:
5820 
        if ftype == TType.STRUCT:
5821 
          self.ex = TransactionServiceException()
5822 
          self.ex.read(iprot)
5823 
        else:
5824 
          iprot.skip(ftype)
5825 
      else:
5826 
        iprot.skip(ftype)
5827 
      iprot.readFieldEnd()
5828 
    iprot.readStructEnd()
5829 
 
5830 
  def write(self, oprot):
5831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5833 
      return
5834 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5835 
    if self.success is not None:
94 ashish 5836 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5837 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5838 
      for iter20 in self.success:
5839 
        iter20.write(oprot)
94 ashish 5840 
      oprot.writeListEnd()
5841 
      oprot.writeFieldEnd()
3431 rajveer 5842 
    if self.ex is not None:
94 ashish 5843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5844 
      self.ex.write(oprot)
5845 
      oprot.writeFieldEnd()
5846 
    oprot.writeFieldStop()
5847 
    oprot.writeStructEnd()
5848 
 
3431 rajveer 5849 
  def validate(self):
5850 
    return
5851 
 
5852 
 
94 ashish 5853 
  def __repr__(self):
5854 
    L = ['%s=%r' % (key, value)
5855 
      for key, value in self.__dict__.iteritems()]
5856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5857 
 
5858 
  def __eq__(self, other):
5859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5860 
 
5861 
  def __ne__(self, other):
5862 
    return not (self == other)
5863 
 
132 ashish 5864 
class getTransactionsForShoppingCartId_args:
5865 
  """
5866 
  Attributes:
5867 
   - shoppingCartId
5868 
  """
5869 
 
5870 
  thrift_spec = (
5871 
    None, # 0
5872 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5873 
  )
5874 
 
5875 
  def __init__(self, shoppingCartId=None,):
5876 
    self.shoppingCartId = shoppingCartId
5877 
 
5878 
  def read(self, iprot):
5879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5881 
      return
5882 
    iprot.readStructBegin()
5883 
    while True:
5884 
      (fname, ftype, fid) = iprot.readFieldBegin()
5885 
      if ftype == TType.STOP:
5886 
        break
5887 
      if fid == 1:
5888 
        if ftype == TType.I64:
5889 
          self.shoppingCartId = iprot.readI64();
5890 
        else:
5891 
          iprot.skip(ftype)
5892 
      else:
5893 
        iprot.skip(ftype)
5894 
      iprot.readFieldEnd()
5895 
    iprot.readStructEnd()
5896 
 
5897 
  def write(self, oprot):
5898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5900 
      return
5901 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5902 
    if self.shoppingCartId is not None:
132 ashish 5903 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5904 
      oprot.writeI64(self.shoppingCartId)
5905 
      oprot.writeFieldEnd()
5906 
    oprot.writeFieldStop()
5907 
    oprot.writeStructEnd()
5908 
 
3431 rajveer 5909 
  def validate(self):
5910 
    return
5911 
 
5912 
 
132 ashish 5913 
  def __repr__(self):
5914 
    L = ['%s=%r' % (key, value)
5915 
      for key, value in self.__dict__.iteritems()]
5916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5917 
 
5918 
  def __eq__(self, other):
5919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5920 
 
5921 
  def __ne__(self, other):
5922 
    return not (self == other)
5923 
 
5924 
class getTransactionsForShoppingCartId_result:
5925 
  """
5926 
  Attributes:
5927 
   - success
5928 
   - ex
5929 
  """
5930 
 
5931 
  thrift_spec = (
5932 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5934 
  )
5935 
 
5936 
  def __init__(self, success=None, ex=None,):
5937 
    self.success = success
5938 
    self.ex = ex
5939 
 
5940 
  def read(self, iprot):
5941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5943 
      return
5944 
    iprot.readStructBegin()
5945 
    while True:
5946 
      (fname, ftype, fid) = iprot.readFieldBegin()
5947 
      if ftype == TType.STOP:
5948 
        break
5949 
      if fid == 0:
5950 
        if ftype == TType.LIST:
5951 
          self.success = []
685 chandransh 5952 
          (_etype24, _size21) = iprot.readListBegin()
5953 
          for _i25 in xrange(_size21):
5954 
            _elem26 = Transaction()
5955 
            _elem26.read(iprot)
5956 
            self.success.append(_elem26)
132 ashish 5957 
          iprot.readListEnd()
5958 
        else:
5959 
          iprot.skip(ftype)
5960 
      elif fid == 1:
5961 
        if ftype == TType.STRUCT:
5962 
          self.ex = TransactionServiceException()
5963 
          self.ex.read(iprot)
5964 
        else:
5965 
          iprot.skip(ftype)
5966 
      else:
5967 
        iprot.skip(ftype)
5968 
      iprot.readFieldEnd()
5969 
    iprot.readStructEnd()
5970 
 
5971 
  def write(self, oprot):
5972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5974 
      return
5975 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5976 
    if self.success is not None:
132 ashish 5977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5978 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5979 
      for iter27 in self.success:
5980 
        iter27.write(oprot)
132 ashish 5981 
      oprot.writeListEnd()
5982 
      oprot.writeFieldEnd()
3431 rajveer 5983 
    if self.ex is not None:
132 ashish 5984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5985 
      self.ex.write(oprot)
5986 
      oprot.writeFieldEnd()
5987 
    oprot.writeFieldStop()
5988 
    oprot.writeStructEnd()
5989 
 
3431 rajveer 5990 
  def validate(self):
5991 
    return
5992 
 
5993 
 
132 ashish 5994 
  def __repr__(self):
5995 
    L = ['%s=%r' % (key, value)
5996 
      for key, value in self.__dict__.iteritems()]
5997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5998 
 
5999 
  def __eq__(self, other):
6000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6001 
 
6002 
  def __ne__(self, other):
6003 
    return not (self == other)
6004 
 
94 ashish 6005 
class getTransactionStatus_args:
6006 
  """
6007 
  Attributes:
6008 
   - transactionId
6009 
  """
6010 
 
6011 
  thrift_spec = (
6012 
    None, # 0
6013 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6014 
  )
6015 
 
6016 
  def __init__(self, transactionId=None,):
6017 
    self.transactionId = transactionId
6018 
 
6019 
  def read(self, iprot):
6020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6022 
      return
6023 
    iprot.readStructBegin()
6024 
    while True:
6025 
      (fname, ftype, fid) = iprot.readFieldBegin()
6026 
      if ftype == TType.STOP:
6027 
        break
6028 
      if fid == 1:
6029 
        if ftype == TType.I64:
6030 
          self.transactionId = iprot.readI64();
6031 
        else:
6032 
          iprot.skip(ftype)
6033 
      else:
6034 
        iprot.skip(ftype)
6035 
      iprot.readFieldEnd()
6036 
    iprot.readStructEnd()
6037 
 
6038 
  def write(self, oprot):
6039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6041 
      return
6042 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6043 
    if self.transactionId is not None:
94 ashish 6044 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6045 
      oprot.writeI64(self.transactionId)
6046 
      oprot.writeFieldEnd()
6047 
    oprot.writeFieldStop()
6048 
    oprot.writeStructEnd()
6049 
 
3431 rajveer 6050 
  def validate(self):
6051 
    return
6052 
 
6053 
 
94 ashish 6054 
  def __repr__(self):
6055 
    L = ['%s=%r' % (key, value)
6056 
      for key, value in self.__dict__.iteritems()]
6057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6058 
 
6059 
  def __eq__(self, other):
6060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6061 
 
6062 
  def __ne__(self, other):
6063 
    return not (self == other)
6064 
 
6065 
class getTransactionStatus_result:
6066 
  """
6067 
  Attributes:
6068 
   - success
6069 
   - ex
6070 
  """
6071 
 
6072 
  thrift_spec = (
6073 
    (0, TType.I32, 'success', None, None, ), # 0
6074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6075 
  )
6076 
 
6077 
  def __init__(self, success=None, ex=None,):
6078 
    self.success = success
6079 
    self.ex = ex
6080 
 
6081 
  def read(self, iprot):
6082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6084 
      return
6085 
    iprot.readStructBegin()
6086 
    while True:
6087 
      (fname, ftype, fid) = iprot.readFieldBegin()
6088 
      if ftype == TType.STOP:
6089 
        break
6090 
      if fid == 0:
6091 
        if ftype == TType.I32:
6092 
          self.success = iprot.readI32();
6093 
        else:
6094 
          iprot.skip(ftype)
6095 
      elif fid == 1:
6096 
        if ftype == TType.STRUCT:
6097 
          self.ex = TransactionServiceException()
6098 
          self.ex.read(iprot)
6099 
        else:
6100 
          iprot.skip(ftype)
6101 
      else:
6102 
        iprot.skip(ftype)
6103 
      iprot.readFieldEnd()
6104 
    iprot.readStructEnd()
6105 
 
6106 
  def write(self, oprot):
6107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6109 
      return
6110 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6111 
    if self.success is not None:
94 ashish 6112 
      oprot.writeFieldBegin('success', TType.I32, 0)
6113 
      oprot.writeI32(self.success)
6114 
      oprot.writeFieldEnd()
3431 rajveer 6115 
    if self.ex is not None:
94 ashish 6116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6117 
      self.ex.write(oprot)
6118 
      oprot.writeFieldEnd()
6119 
    oprot.writeFieldStop()
6120 
    oprot.writeStructEnd()
6121 
 
3431 rajveer 6122 
  def validate(self):
6123 
    return
6124 
 
6125 
 
94 ashish 6126 
  def __repr__(self):
6127 
    L = ['%s=%r' % (key, value)
6128 
      for key, value in self.__dict__.iteritems()]
6129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6130 
 
6131 
  def __eq__(self, other):
6132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6133 
 
6134 
  def __ne__(self, other):
6135 
    return not (self == other)
6136 
 
6137 
class changeTransactionStatus_args:
6138 
  """
6139 
  Attributes:
6140 
   - transactionId
6141 
   - status
6142 
   - description
6143 
  """
6144 
 
6145 
  thrift_spec = (
6146 
    None, # 0
6147 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6148 
    (2, TType.I32, 'status', None, None, ), # 2
6149 
    (3, TType.STRING, 'description', None, None, ), # 3
6150 
  )
6151 
 
6152 
  def __init__(self, transactionId=None, status=None, description=None,):
6153 
    self.transactionId = transactionId
6154 
    self.status = status
6155 
    self.description = description
6156 
 
6157 
  def read(self, iprot):
6158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6160 
      return
6161 
    iprot.readStructBegin()
6162 
    while True:
6163 
      (fname, ftype, fid) = iprot.readFieldBegin()
6164 
      if ftype == TType.STOP:
6165 
        break
6166 
      if fid == 1:
6167 
        if ftype == TType.I64:
6168 
          self.transactionId = iprot.readI64();
6169 
        else:
6170 
          iprot.skip(ftype)
6171 
      elif fid == 2:
6172 
        if ftype == TType.I32:
6173 
          self.status = iprot.readI32();
6174 
        else:
6175 
          iprot.skip(ftype)
6176 
      elif fid == 3:
6177 
        if ftype == TType.STRING:
6178 
          self.description = iprot.readString();
6179 
        else:
6180 
          iprot.skip(ftype)
6181 
      else:
6182 
        iprot.skip(ftype)
6183 
      iprot.readFieldEnd()
6184 
    iprot.readStructEnd()
6185 
 
6186 
  def write(self, oprot):
6187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6189 
      return
6190 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6191 
    if self.transactionId is not None:
94 ashish 6192 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6193 
      oprot.writeI64(self.transactionId)
6194 
      oprot.writeFieldEnd()
3431 rajveer 6195 
    if self.status is not None:
94 ashish 6196 
      oprot.writeFieldBegin('status', TType.I32, 2)
6197 
      oprot.writeI32(self.status)
6198 
      oprot.writeFieldEnd()
3431 rajveer 6199 
    if self.description is not None:
94 ashish 6200 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6201 
      oprot.writeString(self.description)
6202 
      oprot.writeFieldEnd()
6203 
    oprot.writeFieldStop()
6204 
    oprot.writeStructEnd()
6205 
 
3431 rajveer 6206 
  def validate(self):
6207 
    return
6208 
 
6209 
 
94 ashish 6210 
  def __repr__(self):
6211 
    L = ['%s=%r' % (key, value)
6212 
      for key, value in self.__dict__.iteritems()]
6213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6214 
 
6215 
  def __eq__(self, other):
6216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6217 
 
6218 
  def __ne__(self, other):
6219 
    return not (self == other)
6220 
 
6221 
class changeTransactionStatus_result:
6222 
  """
6223 
  Attributes:
6224 
   - success
6225 
   - ex
6226 
  """
6227 
 
6228 
  thrift_spec = (
6229 
    (0, TType.BOOL, 'success', None, None, ), # 0
6230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6231 
  )
6232 
 
6233 
  def __init__(self, success=None, ex=None,):
6234 
    self.success = success
6235 
    self.ex = ex
6236 
 
6237 
  def read(self, iprot):
6238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6240 
      return
6241 
    iprot.readStructBegin()
6242 
    while True:
6243 
      (fname, ftype, fid) = iprot.readFieldBegin()
6244 
      if ftype == TType.STOP:
6245 
        break
6246 
      if fid == 0:
6247 
        if ftype == TType.BOOL:
6248 
          self.success = iprot.readBool();
6249 
        else:
6250 
          iprot.skip(ftype)
6251 
      elif fid == 1:
6252 
        if ftype == TType.STRUCT:
6253 
          self.ex = TransactionServiceException()
6254 
          self.ex.read(iprot)
6255 
        else:
6256 
          iprot.skip(ftype)
6257 
      else:
6258 
        iprot.skip(ftype)
6259 
      iprot.readFieldEnd()
6260 
    iprot.readStructEnd()
6261 
 
6262 
  def write(self, oprot):
6263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6265 
      return
6266 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6267 
    if self.success is not None:
94 ashish 6268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6269 
      oprot.writeBool(self.success)
6270 
      oprot.writeFieldEnd()
3431 rajveer 6271 
    if self.ex is not None:
94 ashish 6272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6273 
      self.ex.write(oprot)
6274 
      oprot.writeFieldEnd()
6275 
    oprot.writeFieldStop()
6276 
    oprot.writeStructEnd()
6277 
 
3431 rajveer 6278 
  def validate(self):
6279 
    return
6280 
 
6281 
 
94 ashish 6282 
  def __repr__(self):
6283 
    L = ['%s=%r' % (key, value)
6284 
      for key, value in self.__dict__.iteritems()]
6285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6286 
 
6287 
  def __eq__(self, other):
6288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6289 
 
6290 
  def __ne__(self, other):
6291 
    return not (self == other)
6292 
 
1398 varun.gupt 6293 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6294 
  """
6295 
  Attributes:
6296 
   - transactionId
6297 
  """
6298 
 
6299 
  thrift_spec = (
6300 
    None, # 0
6301 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6302 
  )
6303 
 
6304 
  def __init__(self, transactionId=None,):
6305 
    self.transactionId = transactionId
6306 
 
6307 
  def read(self, iprot):
6308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6310 
      return
6311 
    iprot.readStructBegin()
6312 
    while True:
6313 
      (fname, ftype, fid) = iprot.readFieldBegin()
6314 
      if ftype == TType.STOP:
6315 
        break
6316 
      if fid == 1:
6317 
        if ftype == TType.I64:
6318 
          self.transactionId = iprot.readI64();
6319 
        else:
6320 
          iprot.skip(ftype)
6321 
      else:
6322 
        iprot.skip(ftype)
6323 
      iprot.readFieldEnd()
6324 
    iprot.readStructEnd()
6325 
 
6326 
  def write(self, oprot):
6327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6329 
      return
1398 varun.gupt 6330 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6331 
    if self.transactionId is not None:
1382 varun.gupt 6332 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6333 
      oprot.writeI64(self.transactionId)
6334 
      oprot.writeFieldEnd()
6335 
    oprot.writeFieldStop()
6336 
    oprot.writeStructEnd()
6337 
 
3431 rajveer 6338 
  def validate(self):
6339 
    return
6340 
 
6341 
 
1382 varun.gupt 6342 
  def __repr__(self):
6343 
    L = ['%s=%r' % (key, value)
6344 
      for key, value in self.__dict__.iteritems()]
6345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6346 
 
6347 
  def __eq__(self, other):
6348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6349 
 
6350 
  def __ne__(self, other):
6351 
    return not (self == other)
6352 
 
1398 varun.gupt 6353 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6354 
  """
6355 
  Attributes:
6356 
   - success
6357 
   - ex
6358 
  """
6359 
 
6360 
  thrift_spec = (
6361 
    (0, TType.BOOL, 'success', None, None, ), # 0
6362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6363 
  )
6364 
 
6365 
  def __init__(self, success=None, ex=None,):
6366 
    self.success = success
6367 
    self.ex = ex
6368 
 
6369 
  def read(self, iprot):
6370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6372 
      return
6373 
    iprot.readStructBegin()
6374 
    while True:
6375 
      (fname, ftype, fid) = iprot.readFieldBegin()
6376 
      if ftype == TType.STOP:
6377 
        break
6378 
      if fid == 0:
6379 
        if ftype == TType.BOOL:
6380 
          self.success = iprot.readBool();
6381 
        else:
6382 
          iprot.skip(ftype)
6383 
      elif fid == 1:
6384 
        if ftype == TType.STRUCT:
6385 
          self.ex = TransactionServiceException()
6386 
          self.ex.read(iprot)
6387 
        else:
6388 
          iprot.skip(ftype)
6389 
      else:
6390 
        iprot.skip(ftype)
6391 
      iprot.readFieldEnd()
6392 
    iprot.readStructEnd()
6393 
 
6394 
  def write(self, oprot):
6395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6397 
      return
1398 varun.gupt 6398 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6399 
    if self.success is not None:
1382 varun.gupt 6400 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6401 
      oprot.writeBool(self.success)
6402 
      oprot.writeFieldEnd()
3431 rajveer 6403 
    if self.ex is not None:
1382 varun.gupt 6404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6405 
      self.ex.write(oprot)
6406 
      oprot.writeFieldEnd()
6407 
    oprot.writeFieldStop()
6408 
    oprot.writeStructEnd()
6409 
 
3431 rajveer 6410 
  def validate(self):
6411 
    return
6412 
 
6413 
 
1382 varun.gupt 6414 
  def __repr__(self):
6415 
    L = ['%s=%r' % (key, value)
6416 
      for key, value in self.__dict__.iteritems()]
6417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6418 
 
6419 
  def __eq__(self, other):
6420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6421 
 
6422 
  def __ne__(self, other):
6423 
    return not (self == other)
6424 
 
483 rajveer 6425 
class getAllOrders_args:
94 ashish 6426 
  """
6427 
  Attributes:
483 rajveer 6428 
   - status
6429 
   - from_date
6430 
   - to_date
6431 
   - warehouse_id
94 ashish 6432 
  """
6433 
 
6434 
  thrift_spec = (
6435 
    None, # 0
483 rajveer 6436 
    (1, TType.I32, 'status', None, None, ), # 1
6437 
    (2, TType.I64, 'from_date', None, None, ), # 2
6438 
    (3, TType.I64, 'to_date', None, None, ), # 3
6439 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6440 
  )
6441 
 
483 rajveer 6442 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6443 
    self.status = status
6444 
    self.from_date = from_date
6445 
    self.to_date = to_date
6446 
    self.warehouse_id = warehouse_id
94 ashish 6447 
 
6448 
  def read(self, iprot):
6449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6451 
      return
6452 
    iprot.readStructBegin()
6453 
    while True:
6454 
      (fname, ftype, fid) = iprot.readFieldBegin()
6455 
      if ftype == TType.STOP:
6456 
        break
6457 
      if fid == 1:
483 rajveer 6458 
        if ftype == TType.I32:
6459 
          self.status = iprot.readI32();
94 ashish 6460 
        else:
6461 
          iprot.skip(ftype)
483 rajveer 6462 
      elif fid == 2:
6463 
        if ftype == TType.I64:
6464 
          self.from_date = iprot.readI64();
94 ashish 6465 
        else:
6466 
          iprot.skip(ftype)
483 rajveer 6467 
      elif fid == 3:
6468 
        if ftype == TType.I64:
6469 
          self.to_date = iprot.readI64();
94 ashish 6470 
        else:
6471 
          iprot.skip(ftype)
483 rajveer 6472 
      elif fid == 4:
94 ashish 6473 
        if ftype == TType.I64:
483 rajveer 6474 
          self.warehouse_id = iprot.readI64();
94 ashish 6475 
        else:
6476 
          iprot.skip(ftype)
6477 
      else:
6478 
        iprot.skip(ftype)
6479 
      iprot.readFieldEnd()
6480 
    iprot.readStructEnd()
6481 
 
6482 
  def write(self, oprot):
6483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6485 
      return
483 rajveer 6486 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6487 
    if self.status is not None:
483 rajveer 6488 
      oprot.writeFieldBegin('status', TType.I32, 1)
6489 
      oprot.writeI32(self.status)
94 ashish 6490 
      oprot.writeFieldEnd()
3431 rajveer 6491 
    if self.from_date is not None:
483 rajveer 6492 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6493 
      oprot.writeI64(self.from_date)
94 ashish 6494 
      oprot.writeFieldEnd()
3431 rajveer 6495 
    if self.to_date is not None:
483 rajveer 6496 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6497 
      oprot.writeI64(self.to_date)
94 ashish 6498 
      oprot.writeFieldEnd()
3431 rajveer 6499 
    if self.warehouse_id is not None:
483 rajveer 6500 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6501 
      oprot.writeI64(self.warehouse_id)
94 ashish 6502 
      oprot.writeFieldEnd()
6503 
    oprot.writeFieldStop()
6504 
    oprot.writeStructEnd()
6505 
 
3431 rajveer 6506 
  def validate(self):
6507 
    return
6508 
 
6509 
 
94 ashish 6510 
  def __repr__(self):
6511 
    L = ['%s=%r' % (key, value)
6512 
      for key, value in self.__dict__.iteritems()]
6513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6514 
 
6515 
  def __eq__(self, other):
6516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6517 
 
6518 
  def __ne__(self, other):
6519 
    return not (self == other)
6520 
 
483 rajveer 6521 
class getAllOrders_result:
94 ashish 6522 
  """
6523 
  Attributes:
6524 
   - success
6525 
   - ex
6526 
  """
6527 
 
6528 
  thrift_spec = (
483 rajveer 6529 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6531 
  )
6532 
 
6533 
  def __init__(self, success=None, ex=None,):
6534 
    self.success = success
6535 
    self.ex = ex
6536 
 
6537 
  def read(self, iprot):
6538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6540 
      return
6541 
    iprot.readStructBegin()
6542 
    while True:
6543 
      (fname, ftype, fid) = iprot.readFieldBegin()
6544 
      if ftype == TType.STOP:
6545 
        break
6546 
      if fid == 0:
483 rajveer 6547 
        if ftype == TType.LIST:
6548 
          self.success = []
685 chandransh 6549 
          (_etype31, _size28) = iprot.readListBegin()
6550 
          for _i32 in xrange(_size28):
6551 
            _elem33 = Order()
6552 
            _elem33.read(iprot)
6553 
            self.success.append(_elem33)
483 rajveer 6554 
          iprot.readListEnd()
94 ashish 6555 
        else:
6556 
          iprot.skip(ftype)
6557 
      elif fid == 1:
6558 
        if ftype == TType.STRUCT:
6559 
          self.ex = TransactionServiceException()
6560 
          self.ex.read(iprot)
6561 
        else:
6562 
          iprot.skip(ftype)
6563 
      else:
6564 
        iprot.skip(ftype)
6565 
      iprot.readFieldEnd()
6566 
    iprot.readStructEnd()
6567 
 
6568 
  def write(self, oprot):
6569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6571 
      return
483 rajveer 6572 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6573 
    if self.success is not None:
483 rajveer 6574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6575 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6576 
      for iter34 in self.success:
6577 
        iter34.write(oprot)
483 rajveer 6578 
      oprot.writeListEnd()
94 ashish 6579 
      oprot.writeFieldEnd()
3431 rajveer 6580 
    if self.ex is not None:
94 ashish 6581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6582 
      self.ex.write(oprot)
6583 
      oprot.writeFieldEnd()
6584 
    oprot.writeFieldStop()
6585 
    oprot.writeStructEnd()
6586 
 
3431 rajveer 6587 
  def validate(self):
6588 
    return
6589 
 
6590 
 
94 ashish 6591 
  def __repr__(self):
6592 
    L = ['%s=%r' % (key, value)
6593 
      for key, value in self.__dict__.iteritems()]
6594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6595 
 
6596 
  def __eq__(self, other):
6597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6598 
 
6599 
  def __ne__(self, other):
6600 
    return not (self == other)
6601 
 
4133 chandransh 6602 
class getOrdersInBatch_args:
6603 
  """
6604 
  Attributes:
6605 
   - statuses
6606 
   - offset
6607 
   - limit
6608 
   - warehouse_id
6609 
  """
6610 
 
6611 
  thrift_spec = (
6612 
    None, # 0
6613 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6614 
    (2, TType.I64, 'offset', None, None, ), # 2
6615 
    (3, TType.I64, 'limit', None, None, ), # 3
6616 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6617 
  )
6618 
 
6619 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6620 
    self.statuses = statuses
6621 
    self.offset = offset
6622 
    self.limit = limit
6623 
    self.warehouse_id = warehouse_id
6624 
 
6625 
  def read(self, iprot):
6626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6628 
      return
6629 
    iprot.readStructBegin()
6630 
    while True:
6631 
      (fname, ftype, fid) = iprot.readFieldBegin()
6632 
      if ftype == TType.STOP:
6633 
        break
6634 
      if fid == 1:
6635 
        if ftype == TType.LIST:
6636 
          self.statuses = []
6637 
          (_etype38, _size35) = iprot.readListBegin()
6638 
          for _i39 in xrange(_size35):
6639 
            _elem40 = iprot.readI32();
6640 
            self.statuses.append(_elem40)
6641 
          iprot.readListEnd()
6642 
        else:
6643 
          iprot.skip(ftype)
6644 
      elif fid == 2:
6645 
        if ftype == TType.I64:
6646 
          self.offset = iprot.readI64();
6647 
        else:
6648 
          iprot.skip(ftype)
6649 
      elif fid == 3:
6650 
        if ftype == TType.I64:
6651 
          self.limit = iprot.readI64();
6652 
        else:
6653 
          iprot.skip(ftype)
6654 
      elif fid == 4:
6655 
        if ftype == TType.I64:
6656 
          self.warehouse_id = iprot.readI64();
6657 
        else:
6658 
          iprot.skip(ftype)
6659 
      else:
6660 
        iprot.skip(ftype)
6661 
      iprot.readFieldEnd()
6662 
    iprot.readStructEnd()
6663 
 
6664 
  def write(self, oprot):
6665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6667 
      return
6668 
    oprot.writeStructBegin('getOrdersInBatch_args')
6669 
    if self.statuses is not None:
6670 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6671 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6672 
      for iter41 in self.statuses:
6673 
        oprot.writeI32(iter41)
6674 
      oprot.writeListEnd()
6675 
      oprot.writeFieldEnd()
6676 
    if self.offset is not None:
6677 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6678 
      oprot.writeI64(self.offset)
6679 
      oprot.writeFieldEnd()
6680 
    if self.limit is not None:
6681 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6682 
      oprot.writeI64(self.limit)
6683 
      oprot.writeFieldEnd()
6684 
    if self.warehouse_id is not None:
6685 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6686 
      oprot.writeI64(self.warehouse_id)
6687 
      oprot.writeFieldEnd()
6688 
    oprot.writeFieldStop()
6689 
    oprot.writeStructEnd()
6690 
 
6691 
  def validate(self):
6692 
    return
6693 
 
6694 
 
6695 
  def __repr__(self):
6696 
    L = ['%s=%r' % (key, value)
6697 
      for key, value in self.__dict__.iteritems()]
6698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6699 
 
6700 
  def __eq__(self, other):
6701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6702 
 
6703 
  def __ne__(self, other):
6704 
    return not (self == other)
6705 
 
6706 
class getOrdersInBatch_result:
6707 
  """
6708 
  Attributes:
6709 
   - success
6710 
   - ex
6711 
  """
6712 
 
6713 
  thrift_spec = (
6714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6716 
  )
6717 
 
6718 
  def __init__(self, success=None, ex=None,):
6719 
    self.success = success
6720 
    self.ex = ex
6721 
 
6722 
  def read(self, iprot):
6723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6725 
      return
6726 
    iprot.readStructBegin()
6727 
    while True:
6728 
      (fname, ftype, fid) = iprot.readFieldBegin()
6729 
      if ftype == TType.STOP:
6730 
        break
6731 
      if fid == 0:
6732 
        if ftype == TType.LIST:
6733 
          self.success = []
6734 
          (_etype45, _size42) = iprot.readListBegin()
6735 
          for _i46 in xrange(_size42):
6736 
            _elem47 = Order()
6737 
            _elem47.read(iprot)
6738 
            self.success.append(_elem47)
6739 
          iprot.readListEnd()
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      elif fid == 1:
6743 
        if ftype == TType.STRUCT:
6744 
          self.ex = TransactionServiceException()
6745 
          self.ex.read(iprot)
6746 
        else:
6747 
          iprot.skip(ftype)
6748 
      else:
6749 
        iprot.skip(ftype)
6750 
      iprot.readFieldEnd()
6751 
    iprot.readStructEnd()
6752 
 
6753 
  def write(self, oprot):
6754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6756 
      return
6757 
    oprot.writeStructBegin('getOrdersInBatch_result')
6758 
    if self.success is not None:
6759 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6760 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6761 
      for iter48 in self.success:
6762 
        iter48.write(oprot)
6763 
      oprot.writeListEnd()
6764 
      oprot.writeFieldEnd()
6765 
    if self.ex is not None:
6766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6767 
      self.ex.write(oprot)
6768 
      oprot.writeFieldEnd()
6769 
    oprot.writeFieldStop()
6770 
    oprot.writeStructEnd()
6771 
 
6772 
  def validate(self):
6773 
    return
6774 
 
6775 
 
6776 
  def __repr__(self):
6777 
    L = ['%s=%r' % (key, value)
6778 
      for key, value in self.__dict__.iteritems()]
6779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6780 
 
6781 
  def __eq__(self, other):
6782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6783 
 
6784 
  def __ne__(self, other):
6785 
    return not (self == other)
6786 
 
6787 
class getOrderCount_args:
6788 
  """
6789 
  Attributes:
6790 
   - statuses
6791 
   - warehouseId
6792 
  """
6793 
 
6794 
  thrift_spec = (
6795 
    None, # 0
6796 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6797 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6798 
  )
6799 
 
6800 
  def __init__(self, statuses=None, warehouseId=None,):
6801 
    self.statuses = statuses
6802 
    self.warehouseId = warehouseId
6803 
 
6804 
  def read(self, iprot):
6805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6807 
      return
6808 
    iprot.readStructBegin()
6809 
    while True:
6810 
      (fname, ftype, fid) = iprot.readFieldBegin()
6811 
      if ftype == TType.STOP:
6812 
        break
6813 
      if fid == 1:
6814 
        if ftype == TType.LIST:
6815 
          self.statuses = []
6816 
          (_etype52, _size49) = iprot.readListBegin()
6817 
          for _i53 in xrange(_size49):
6818 
            _elem54 = iprot.readI32();
6819 
            self.statuses.append(_elem54)
6820 
          iprot.readListEnd()
6821 
        else:
6822 
          iprot.skip(ftype)
6823 
      elif fid == 2:
6824 
        if ftype == TType.I64:
6825 
          self.warehouseId = iprot.readI64();
6826 
        else:
6827 
          iprot.skip(ftype)
6828 
      else:
6829 
        iprot.skip(ftype)
6830 
      iprot.readFieldEnd()
6831 
    iprot.readStructEnd()
6832 
 
6833 
  def write(self, oprot):
6834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6836 
      return
6837 
    oprot.writeStructBegin('getOrderCount_args')
6838 
    if self.statuses is not None:
6839 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6840 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6841 
      for iter55 in self.statuses:
6842 
        oprot.writeI32(iter55)
6843 
      oprot.writeListEnd()
6844 
      oprot.writeFieldEnd()
6845 
    if self.warehouseId is not None:
6846 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6847 
      oprot.writeI64(self.warehouseId)
6848 
      oprot.writeFieldEnd()
6849 
    oprot.writeFieldStop()
6850 
    oprot.writeStructEnd()
6851 
 
6852 
  def validate(self):
6853 
    return
6854 
 
6855 
 
6856 
  def __repr__(self):
6857 
    L = ['%s=%r' % (key, value)
6858 
      for key, value in self.__dict__.iteritems()]
6859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6860 
 
6861 
  def __eq__(self, other):
6862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6863 
 
6864 
  def __ne__(self, other):
6865 
    return not (self == other)
6866 
 
6867 
class getOrderCount_result:
6868 
  """
6869 
  Attributes:
6870 
   - success
6871 
   - ex
6872 
  """
6873 
 
6874 
  thrift_spec = (
6875 
    (0, TType.I32, 'success', None, None, ), # 0
6876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6877 
  )
6878 
 
6879 
  def __init__(self, success=None, ex=None,):
6880 
    self.success = success
6881 
    self.ex = ex
6882 
 
6883 
  def read(self, iprot):
6884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6886 
      return
6887 
    iprot.readStructBegin()
6888 
    while True:
6889 
      (fname, ftype, fid) = iprot.readFieldBegin()
6890 
      if ftype == TType.STOP:
6891 
        break
6892 
      if fid == 0:
6893 
        if ftype == TType.I32:
6894 
          self.success = iprot.readI32();
6895 
        else:
6896 
          iprot.skip(ftype)
6897 
      elif fid == 1:
6898 
        if ftype == TType.STRUCT:
6899 
          self.ex = TransactionServiceException()
6900 
          self.ex.read(iprot)
6901 
        else:
6902 
          iprot.skip(ftype)
6903 
      else:
6904 
        iprot.skip(ftype)
6905 
      iprot.readFieldEnd()
6906 
    iprot.readStructEnd()
6907 
 
6908 
  def write(self, oprot):
6909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6911 
      return
6912 
    oprot.writeStructBegin('getOrderCount_result')
6913 
    if self.success is not None:
6914 
      oprot.writeFieldBegin('success', TType.I32, 0)
6915 
      oprot.writeI32(self.success)
6916 
      oprot.writeFieldEnd()
6917 
    if self.ex is not None:
6918 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6919 
      self.ex.write(oprot)
6920 
      oprot.writeFieldEnd()
6921 
    oprot.writeFieldStop()
6922 
    oprot.writeStructEnd()
6923 
 
6924 
  def validate(self):
6925 
    return
6926 
 
6927 
 
6928 
  def __repr__(self):
6929 
    L = ['%s=%r' % (key, value)
6930 
      for key, value in self.__dict__.iteritems()]
6931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6932 
 
6933 
  def __eq__(self, other):
6934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6935 
 
6936 
  def __ne__(self, other):
6937 
    return not (self == other)
6938 
 
999 varun.gupt 6939 
class getOrdersByBillingDate_args:
6940 
  """
6941 
  Attributes:
6942 
   - status
6943 
   - start_billing_date
6944 
   - end_billing_date
6945 
   - warehouse_id
6946 
  """
6947 
 
6948 
  thrift_spec = (
6949 
    None, # 0
6950 
    (1, TType.I32, 'status', None, None, ), # 1
6951 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6952 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6953 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6954 
  )
6955 
 
6956 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6957 
    self.status = status
6958 
    self.start_billing_date = start_billing_date
6959 
    self.end_billing_date = end_billing_date
6960 
    self.warehouse_id = warehouse_id
6961 
 
6962 
  def read(self, iprot):
6963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6965 
      return
6966 
    iprot.readStructBegin()
6967 
    while True:
6968 
      (fname, ftype, fid) = iprot.readFieldBegin()
6969 
      if ftype == TType.STOP:
6970 
        break
6971 
      if fid == 1:
6972 
        if ftype == TType.I32:
6973 
          self.status = iprot.readI32();
6974 
        else:
6975 
          iprot.skip(ftype)
6976 
      elif fid == 2:
6977 
        if ftype == TType.I64:
6978 
          self.start_billing_date = iprot.readI64();
6979 
        else:
6980 
          iprot.skip(ftype)
6981 
      elif fid == 3:
6982 
        if ftype == TType.I64:
6983 
          self.end_billing_date = iprot.readI64();
6984 
        else:
6985 
          iprot.skip(ftype)
6986 
      elif fid == 4:
6987 
        if ftype == TType.I64:
6988 
          self.warehouse_id = iprot.readI64();
6989 
        else:
6990 
          iprot.skip(ftype)
6991 
      else:
6992 
        iprot.skip(ftype)
6993 
      iprot.readFieldEnd()
6994 
    iprot.readStructEnd()
6995 
 
6996 
  def write(self, oprot):
6997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6999 
      return
7000 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7001 
    if self.status is not None:
999 varun.gupt 7002 
      oprot.writeFieldBegin('status', TType.I32, 1)
7003 
      oprot.writeI32(self.status)
7004 
      oprot.writeFieldEnd()
3431 rajveer 7005 
    if self.start_billing_date is not None:
999 varun.gupt 7006 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7007 
      oprot.writeI64(self.start_billing_date)
7008 
      oprot.writeFieldEnd()
3431 rajveer 7009 
    if self.end_billing_date is not None:
999 varun.gupt 7010 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7011 
      oprot.writeI64(self.end_billing_date)
7012 
      oprot.writeFieldEnd()
3431 rajveer 7013 
    if self.warehouse_id is not None:
999 varun.gupt 7014 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7015 
      oprot.writeI64(self.warehouse_id)
7016 
      oprot.writeFieldEnd()
7017 
    oprot.writeFieldStop()
7018 
    oprot.writeStructEnd()
7019 
 
3431 rajveer 7020 
  def validate(self):
7021 
    return
7022 
 
7023 
 
999 varun.gupt 7024 
  def __repr__(self):
7025 
    L = ['%s=%r' % (key, value)
7026 
      for key, value in self.__dict__.iteritems()]
7027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7028 
 
7029 
  def __eq__(self, other):
7030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7031 
 
7032 
  def __ne__(self, other):
7033 
    return not (self == other)
7034 
 
7035 
class getOrdersByBillingDate_result:
7036 
  """
7037 
  Attributes:
7038 
   - success
7039 
   - ex
7040 
  """
7041 
 
7042 
  thrift_spec = (
7043 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7045 
  )
7046 
 
7047 
  def __init__(self, success=None, ex=None,):
7048 
    self.success = success
7049 
    self.ex = ex
7050 
 
7051 
  def read(self, iprot):
7052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7054 
      return
7055 
    iprot.readStructBegin()
7056 
    while True:
7057 
      (fname, ftype, fid) = iprot.readFieldBegin()
7058 
      if ftype == TType.STOP:
7059 
        break
7060 
      if fid == 0:
7061 
        if ftype == TType.LIST:
7062 
          self.success = []
4133 chandransh 7063 
          (_etype59, _size56) = iprot.readListBegin()
7064 
          for _i60 in xrange(_size56):
7065 
            _elem61 = Order()
7066 
            _elem61.read(iprot)
7067 
            self.success.append(_elem61)
999 varun.gupt 7068 
          iprot.readListEnd()
7069 
        else:
7070 
          iprot.skip(ftype)
7071 
      elif fid == 1:
7072 
        if ftype == TType.STRUCT:
7073 
          self.ex = TransactionServiceException()
7074 
          self.ex.read(iprot)
7075 
        else:
7076 
          iprot.skip(ftype)
7077 
      else:
7078 
        iprot.skip(ftype)
7079 
      iprot.readFieldEnd()
7080 
    iprot.readStructEnd()
7081 
 
7082 
  def write(self, oprot):
7083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7085 
      return
7086 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7087 
    if self.success is not None:
999 varun.gupt 7088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7089 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7090 
      for iter62 in self.success:
7091 
        iter62.write(oprot)
999 varun.gupt 7092 
      oprot.writeListEnd()
7093 
      oprot.writeFieldEnd()
3431 rajveer 7094 
    if self.ex is not None:
999 varun.gupt 7095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7096 
      self.ex.write(oprot)
7097 
      oprot.writeFieldEnd()
7098 
    oprot.writeFieldStop()
7099 
    oprot.writeStructEnd()
7100 
 
3431 rajveer 7101 
  def validate(self):
7102 
    return
7103 
 
7104 
 
999 varun.gupt 7105 
  def __repr__(self):
7106 
    L = ['%s=%r' % (key, value)
7107 
      for key, value in self.__dict__.iteritems()]
7108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7109 
 
7110 
  def __eq__(self, other):
7111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7112 
 
7113 
  def __ne__(self, other):
7114 
    return not (self == other)
7115 
 
3427 chandransh 7116 
class getOrdersByShippingDate_args:
7117 
  """
7118 
  Attributes:
7119 
   - fromShippingDate
7120 
   - toShippingDate
7121 
   - providerId
7122 
   - warehouseId
3451 chandransh 7123 
   - cod
3427 chandransh 7124 
  """
7125 
 
7126 
  thrift_spec = (
7127 
    None, # 0
7128 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7129 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7130 
    (3, TType.I64, 'providerId', None, None, ), # 3
7131 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7132 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7133 
  )
7134 
 
3451 chandransh 7135 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7136 
    self.fromShippingDate = fromShippingDate
7137 
    self.toShippingDate = toShippingDate
7138 
    self.providerId = providerId
7139 
    self.warehouseId = warehouseId
3451 chandransh 7140 
    self.cod = cod
3427 chandransh 7141 
 
7142 
  def read(self, iprot):
7143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7145 
      return
7146 
    iprot.readStructBegin()
7147 
    while True:
7148 
      (fname, ftype, fid) = iprot.readFieldBegin()
7149 
      if ftype == TType.STOP:
7150 
        break
7151 
      if fid == 1:
7152 
        if ftype == TType.I64:
7153 
          self.fromShippingDate = iprot.readI64();
7154 
        else:
7155 
          iprot.skip(ftype)
7156 
      elif fid == 2:
7157 
        if ftype == TType.I64:
7158 
          self.toShippingDate = iprot.readI64();
7159 
        else:
7160 
          iprot.skip(ftype)
7161 
      elif fid == 3:
7162 
        if ftype == TType.I64:
7163 
          self.providerId = iprot.readI64();
7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      elif fid == 4:
7167 
        if ftype == TType.I64:
7168 
          self.warehouseId = iprot.readI64();
7169 
        else:
7170 
          iprot.skip(ftype)
3451 chandransh 7171 
      elif fid == 5:
7172 
        if ftype == TType.BOOL:
7173 
          self.cod = iprot.readBool();
7174 
        else:
7175 
          iprot.skip(ftype)
3427 chandransh 7176 
      else:
7177 
        iprot.skip(ftype)
7178 
      iprot.readFieldEnd()
7179 
    iprot.readStructEnd()
7180 
 
7181 
  def write(self, oprot):
7182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7184 
      return
7185 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7186 
    if self.fromShippingDate is not None:
3427 chandransh 7187 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7188 
      oprot.writeI64(self.fromShippingDate)
7189 
      oprot.writeFieldEnd()
3431 rajveer 7190 
    if self.toShippingDate is not None:
3427 chandransh 7191 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7192 
      oprot.writeI64(self.toShippingDate)
7193 
      oprot.writeFieldEnd()
3431 rajveer 7194 
    if self.providerId is not None:
3427 chandransh 7195 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7196 
      oprot.writeI64(self.providerId)
7197 
      oprot.writeFieldEnd()
3431 rajveer 7198 
    if self.warehouseId is not None:
3427 chandransh 7199 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7200 
      oprot.writeI64(self.warehouseId)
7201 
      oprot.writeFieldEnd()
3451 chandransh 7202 
    if self.cod is not None:
7203 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7204 
      oprot.writeBool(self.cod)
7205 
      oprot.writeFieldEnd()
3427 chandransh 7206 
    oprot.writeFieldStop()
7207 
    oprot.writeStructEnd()
7208 
 
3431 rajveer 7209 
  def validate(self):
7210 
    return
7211 
 
7212 
 
3427 chandransh 7213 
  def __repr__(self):
7214 
    L = ['%s=%r' % (key, value)
7215 
      for key, value in self.__dict__.iteritems()]
7216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7217 
 
7218 
  def __eq__(self, other):
7219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7220 
 
7221 
  def __ne__(self, other):
7222 
    return not (self == other)
7223 
 
7224 
class getOrdersByShippingDate_result:
7225 
  """
7226 
  Attributes:
7227 
   - success
7228 
   - ex
7229 
  """
7230 
 
7231 
  thrift_spec = (
7232 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7234 
  )
7235 
 
7236 
  def __init__(self, success=None, ex=None,):
7237 
    self.success = success
7238 
    self.ex = ex
7239 
 
7240 
  def read(self, iprot):
7241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7243 
      return
7244 
    iprot.readStructBegin()
7245 
    while True:
7246 
      (fname, ftype, fid) = iprot.readFieldBegin()
7247 
      if ftype == TType.STOP:
7248 
        break
7249 
      if fid == 0:
7250 
        if ftype == TType.LIST:
7251 
          self.success = []
4133 chandransh 7252 
          (_etype66, _size63) = iprot.readListBegin()
7253 
          for _i67 in xrange(_size63):
7254 
            _elem68 = Order()
7255 
            _elem68.read(iprot)
7256 
            self.success.append(_elem68)
3427 chandransh 7257 
          iprot.readListEnd()
7258 
        else:
7259 
          iprot.skip(ftype)
7260 
      elif fid == 1:
7261 
        if ftype == TType.STRUCT:
7262 
          self.ex = TransactionServiceException()
7263 
          self.ex.read(iprot)
7264 
        else:
7265 
          iprot.skip(ftype)
7266 
      else:
7267 
        iprot.skip(ftype)
7268 
      iprot.readFieldEnd()
7269 
    iprot.readStructEnd()
7270 
 
7271 
  def write(self, oprot):
7272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7274 
      return
7275 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7276 
    if self.success is not None:
3427 chandransh 7277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7279 
      for iter69 in self.success:
7280 
        iter69.write(oprot)
3427 chandransh 7281 
      oprot.writeListEnd()
7282 
      oprot.writeFieldEnd()
3431 rajveer 7283 
    if self.ex is not None:
3427 chandransh 7284 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7285 
      self.ex.write(oprot)
7286 
      oprot.writeFieldEnd()
7287 
    oprot.writeFieldStop()
7288 
    oprot.writeStructEnd()
7289 
 
3431 rajveer 7290 
  def validate(self):
7291 
    return
7292 
 
7293 
 
3427 chandransh 7294 
  def __repr__(self):
7295 
    L = ['%s=%r' % (key, value)
7296 
      for key, value in self.__dict__.iteritems()]
7297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7298 
 
7299 
  def __eq__(self, other):
7300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7301 
 
7302 
  def __ne__(self, other):
7303 
    return not (self == other)
7304 
 
1382 varun.gupt 7305 
class getReturnableOrdersForCustomer_args:
7306 
  """
7307 
  Attributes:
7308 
   - customer_id
7309 
   - limit
7310 
  """
7311 
 
7312 
  thrift_spec = (
7313 
    None, # 0
7314 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7315 
    (2, TType.I64, 'limit', None, None, ), # 2
7316 
  )
7317 
 
7318 
  def __init__(self, customer_id=None, limit=None,):
7319 
    self.customer_id = customer_id
7320 
    self.limit = limit
7321 
 
7322 
  def read(self, iprot):
7323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7325 
      return
7326 
    iprot.readStructBegin()
7327 
    while True:
7328 
      (fname, ftype, fid) = iprot.readFieldBegin()
7329 
      if ftype == TType.STOP:
7330 
        break
7331 
      if fid == 1:
7332 
        if ftype == TType.I64:
7333 
          self.customer_id = iprot.readI64();
7334 
        else:
7335 
          iprot.skip(ftype)
7336 
      elif fid == 2:
7337 
        if ftype == TType.I64:
7338 
          self.limit = iprot.readI64();
7339 
        else:
7340 
          iprot.skip(ftype)
7341 
      else:
7342 
        iprot.skip(ftype)
7343 
      iprot.readFieldEnd()
7344 
    iprot.readStructEnd()
7345 
 
7346 
  def write(self, oprot):
7347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7349 
      return
7350 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7351 
    if self.customer_id is not None:
1382 varun.gupt 7352 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7353 
      oprot.writeI64(self.customer_id)
7354 
      oprot.writeFieldEnd()
3431 rajveer 7355 
    if self.limit is not None:
1382 varun.gupt 7356 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7357 
      oprot.writeI64(self.limit)
7358 
      oprot.writeFieldEnd()
7359 
    oprot.writeFieldStop()
7360 
    oprot.writeStructEnd()
7361 
 
3431 rajveer 7362 
  def validate(self):
7363 
    return
7364 
 
7365 
 
1382 varun.gupt 7366 
  def __repr__(self):
7367 
    L = ['%s=%r' % (key, value)
7368 
      for key, value in self.__dict__.iteritems()]
7369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7370 
 
7371 
  def __eq__(self, other):
7372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7373 
 
7374 
  def __ne__(self, other):
7375 
    return not (self == other)
7376 
 
7377 
class getReturnableOrdersForCustomer_result:
7378 
  """
7379 
  Attributes:
7380 
   - success
7381 
   - ex
7382 
  """
7383 
 
7384 
  thrift_spec = (
7385 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7387 
  )
7388 
 
7389 
  def __init__(self, success=None, ex=None,):
7390 
    self.success = success
7391 
    self.ex = ex
7392 
 
7393 
  def read(self, iprot):
7394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7396 
      return
7397 
    iprot.readStructBegin()
7398 
    while True:
7399 
      (fname, ftype, fid) = iprot.readFieldBegin()
7400 
      if ftype == TType.STOP:
7401 
        break
7402 
      if fid == 0:
7403 
        if ftype == TType.LIST:
7404 
          self.success = []
4133 chandransh 7405 
          (_etype73, _size70) = iprot.readListBegin()
7406 
          for _i74 in xrange(_size70):
7407 
            _elem75 = iprot.readI64();
7408 
            self.success.append(_elem75)
1382 varun.gupt 7409 
          iprot.readListEnd()
7410 
        else:
7411 
          iprot.skip(ftype)
7412 
      elif fid == 1:
7413 
        if ftype == TType.STRUCT:
7414 
          self.ex = TransactionServiceException()
7415 
          self.ex.read(iprot)
7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      else:
7419 
        iprot.skip(ftype)
7420 
      iprot.readFieldEnd()
7421 
    iprot.readStructEnd()
7422 
 
7423 
  def write(self, oprot):
7424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7426 
      return
7427 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7428 
    if self.success is not None:
1382 varun.gupt 7429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7430 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7431 
      for iter76 in self.success:
7432 
        oprot.writeI64(iter76)
1382 varun.gupt 7433 
      oprot.writeListEnd()
7434 
      oprot.writeFieldEnd()
3431 rajveer 7435 
    if self.ex is not None:
1382 varun.gupt 7436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7437 
      self.ex.write(oprot)
7438 
      oprot.writeFieldEnd()
7439 
    oprot.writeFieldStop()
7440 
    oprot.writeStructEnd()
7441 
 
3431 rajveer 7442 
  def validate(self):
7443 
    return
7444 
 
7445 
 
1382 varun.gupt 7446 
  def __repr__(self):
7447 
    L = ['%s=%r' % (key, value)
7448 
      for key, value in self.__dict__.iteritems()]
7449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7450 
 
7451 
  def __eq__(self, other):
7452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7453 
 
7454 
  def __ne__(self, other):
7455 
    return not (self == other)
7456 
 
7457 
class getCancellableOrdersForCustomer_args:
7458 
  """
7459 
  Attributes:
7460 
   - customer_id
7461 
   - limit
7462 
  """
7463 
 
7464 
  thrift_spec = (
7465 
    None, # 0
7466 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7467 
    (2, TType.I64, 'limit', None, None, ), # 2
7468 
  )
7469 
 
7470 
  def __init__(self, customer_id=None, limit=None,):
7471 
    self.customer_id = customer_id
7472 
    self.limit = limit
7473 
 
7474 
  def read(self, iprot):
7475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7477 
      return
7478 
    iprot.readStructBegin()
7479 
    while True:
7480 
      (fname, ftype, fid) = iprot.readFieldBegin()
7481 
      if ftype == TType.STOP:
7482 
        break
7483 
      if fid == 1:
7484 
        if ftype == TType.I64:
7485 
          self.customer_id = iprot.readI64();
7486 
        else:
7487 
          iprot.skip(ftype)
7488 
      elif fid == 2:
7489 
        if ftype == TType.I64:
7490 
          self.limit = iprot.readI64();
7491 
        else:
7492 
          iprot.skip(ftype)
7493 
      else:
7494 
        iprot.skip(ftype)
7495 
      iprot.readFieldEnd()
7496 
    iprot.readStructEnd()
7497 
 
7498 
  def write(self, oprot):
7499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7501 
      return
7502 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7503 
    if self.customer_id is not None:
1382 varun.gupt 7504 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7505 
      oprot.writeI64(self.customer_id)
7506 
      oprot.writeFieldEnd()
3431 rajveer 7507 
    if self.limit is not None:
1382 varun.gupt 7508 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7509 
      oprot.writeI64(self.limit)
7510 
      oprot.writeFieldEnd()
7511 
    oprot.writeFieldStop()
7512 
    oprot.writeStructEnd()
7513 
 
3431 rajveer 7514 
  def validate(self):
7515 
    return
7516 
 
7517 
 
1382 varun.gupt 7518 
  def __repr__(self):
7519 
    L = ['%s=%r' % (key, value)
7520 
      for key, value in self.__dict__.iteritems()]
7521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7522 
 
7523 
  def __eq__(self, other):
7524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7525 
 
7526 
  def __ne__(self, other):
7527 
    return not (self == other)
7528 
 
7529 
class getCancellableOrdersForCustomer_result:
7530 
  """
7531 
  Attributes:
7532 
   - success
7533 
   - ex
7534 
  """
7535 
 
7536 
  thrift_spec = (
7537 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7539 
  )
7540 
 
7541 
  def __init__(self, success=None, ex=None,):
7542 
    self.success = success
7543 
    self.ex = ex
7544 
 
7545 
  def read(self, iprot):
7546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7548 
      return
7549 
    iprot.readStructBegin()
7550 
    while True:
7551 
      (fname, ftype, fid) = iprot.readFieldBegin()
7552 
      if ftype == TType.STOP:
7553 
        break
7554 
      if fid == 0:
7555 
        if ftype == TType.LIST:
7556 
          self.success = []
4133 chandransh 7557 
          (_etype80, _size77) = iprot.readListBegin()
7558 
          for _i81 in xrange(_size77):
7559 
            _elem82 = iprot.readI64();
7560 
            self.success.append(_elem82)
1382 varun.gupt 7561 
          iprot.readListEnd()
7562 
        else:
7563 
          iprot.skip(ftype)
7564 
      elif fid == 1:
7565 
        if ftype == TType.STRUCT:
7566 
          self.ex = TransactionServiceException()
7567 
          self.ex.read(iprot)
7568 
        else:
7569 
          iprot.skip(ftype)
7570 
      else:
7571 
        iprot.skip(ftype)
7572 
      iprot.readFieldEnd()
7573 
    iprot.readStructEnd()
7574 
 
7575 
  def write(self, oprot):
7576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7578 
      return
7579 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7580 
    if self.success is not None:
1382 varun.gupt 7581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7582 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7583 
      for iter83 in self.success:
7584 
        oprot.writeI64(iter83)
1382 varun.gupt 7585 
      oprot.writeListEnd()
7586 
      oprot.writeFieldEnd()
3431 rajveer 7587 
    if self.ex is not None:
1382 varun.gupt 7588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7589 
      self.ex.write(oprot)
7590 
      oprot.writeFieldEnd()
7591 
    oprot.writeFieldStop()
7592 
    oprot.writeStructEnd()
7593 
 
3431 rajveer 7594 
  def validate(self):
7595 
    return
7596 
 
7597 
 
1382 varun.gupt 7598 
  def __repr__(self):
7599 
    L = ['%s=%r' % (key, value)
7600 
      for key, value in self.__dict__.iteritems()]
7601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7602 
 
7603 
  def __eq__(self, other):
7604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7605 
 
7606 
  def __ne__(self, other):
7607 
    return not (self == other)
7608 
 
483 rajveer 7609 
class changeOrderStatus_args:
94 ashish 7610 
  """
7611 
  Attributes:
483 rajveer 7612 
   - orderId
7613 
   - status
7614 
   - description
94 ashish 7615 
  """
7616 
 
7617 
  thrift_spec = (
7618 
    None, # 0
483 rajveer 7619 
    (1, TType.I64, 'orderId', None, None, ), # 1
7620 
    (2, TType.I32, 'status', None, None, ), # 2
7621 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7622 
  )
7623 
 
483 rajveer 7624 
  def __init__(self, orderId=None, status=None, description=None,):
7625 
    self.orderId = orderId
7626 
    self.status = status
7627 
    self.description = description
94 ashish 7628 
 
7629 
  def read(self, iprot):
7630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7632 
      return
7633 
    iprot.readStructBegin()
7634 
    while True:
7635 
      (fname, ftype, fid) = iprot.readFieldBegin()
7636 
      if ftype == TType.STOP:
7637 
        break
7638 
      if fid == 1:
7639 
        if ftype == TType.I64:
483 rajveer 7640 
          self.orderId = iprot.readI64();
94 ashish 7641 
        else:
7642 
          iprot.skip(ftype)
7643 
      elif fid == 2:
483 rajveer 7644 
        if ftype == TType.I32:
7645 
          self.status = iprot.readI32();
94 ashish 7646 
        else:
7647 
          iprot.skip(ftype)
483 rajveer 7648 
      elif fid == 3:
7649 
        if ftype == TType.STRING:
7650 
          self.description = iprot.readString();
7651 
        else:
7652 
          iprot.skip(ftype)
94 ashish 7653 
      else:
7654 
        iprot.skip(ftype)
7655 
      iprot.readFieldEnd()
7656 
    iprot.readStructEnd()
7657 
 
7658 
  def write(self, oprot):
7659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7661 
      return
483 rajveer 7662 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7663 
    if self.orderId is not None:
483 rajveer 7664 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7665 
      oprot.writeI64(self.orderId)
94 ashish 7666 
      oprot.writeFieldEnd()
3431 rajveer 7667 
    if self.status is not None:
483 rajveer 7668 
      oprot.writeFieldBegin('status', TType.I32, 2)
7669 
      oprot.writeI32(self.status)
94 ashish 7670 
      oprot.writeFieldEnd()
3431 rajveer 7671 
    if self.description is not None:
483 rajveer 7672 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7673 
      oprot.writeString(self.description)
7674 
      oprot.writeFieldEnd()
94 ashish 7675 
    oprot.writeFieldStop()
7676 
    oprot.writeStructEnd()
7677 
 
3431 rajveer 7678 
  def validate(self):
7679 
    return
7680 
 
7681 
 
94 ashish 7682 
  def __repr__(self):
7683 
    L = ['%s=%r' % (key, value)
7684 
      for key, value in self.__dict__.iteritems()]
7685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7686 
 
7687 
  def __eq__(self, other):
7688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7689 
 
7690 
  def __ne__(self, other):
7691 
    return not (self == other)
7692 
 
483 rajveer 7693 
class changeOrderStatus_result:
94 ashish 7694 
  """
7695 
  Attributes:
7696 
   - success
7697 
   - ex
7698 
  """
7699 
 
7700 
  thrift_spec = (
7701 
    (0, TType.BOOL, 'success', None, None, ), # 0
7702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7703 
  )
7704 
 
7705 
  def __init__(self, success=None, ex=None,):
7706 
    self.success = success
7707 
    self.ex = ex
7708 
 
7709 
  def read(self, iprot):
7710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7712 
      return
7713 
    iprot.readStructBegin()
7714 
    while True:
7715 
      (fname, ftype, fid) = iprot.readFieldBegin()
7716 
      if ftype == TType.STOP:
7717 
        break
7718 
      if fid == 0:
7719 
        if ftype == TType.BOOL:
7720 
          self.success = iprot.readBool();
7721 
        else:
7722 
          iprot.skip(ftype)
7723 
      elif fid == 1:
7724 
        if ftype == TType.STRUCT:
7725 
          self.ex = TransactionServiceException()
7726 
          self.ex.read(iprot)
7727 
        else:
7728 
          iprot.skip(ftype)
7729 
      else:
7730 
        iprot.skip(ftype)
7731 
      iprot.readFieldEnd()
7732 
    iprot.readStructEnd()
7733 
 
7734 
  def write(self, oprot):
7735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7737 
      return
483 rajveer 7738 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7739 
    if self.success is not None:
94 ashish 7740 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7741 
      oprot.writeBool(self.success)
7742 
      oprot.writeFieldEnd()
3431 rajveer 7743 
    if self.ex is not None:
94 ashish 7744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7745 
      self.ex.write(oprot)
7746 
      oprot.writeFieldEnd()
7747 
    oprot.writeFieldStop()
7748 
    oprot.writeStructEnd()
7749 
 
3431 rajveer 7750 
  def validate(self):
7751 
    return
7752 
 
7753 
 
94 ashish 7754 
  def __repr__(self):
7755 
    L = ['%s=%r' % (key, value)
7756 
      for key, value in self.__dict__.iteritems()]
7757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7758 
 
7759 
  def __eq__(self, other):
7760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7761 
 
7762 
  def __ne__(self, other):
7763 
    return not (self == other)
7764 
 
3064 chandransh 7765 
class getOrdersForTransaction_args:
494 rajveer 7766 
  """
7767 
  Attributes:
3064 chandransh 7768 
   - transactionId
7769 
   - customerId
494 rajveer 7770 
  """
7771 
 
7772 
  thrift_spec = (
7773 
    None, # 0
3064 chandransh 7774 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7775 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7776 
  )
7777 
 
3064 chandransh 7778 
  def __init__(self, transactionId=None, customerId=None,):
7779 
    self.transactionId = transactionId
7780 
    self.customerId = customerId
494 rajveer 7781 
 
7782 
  def read(self, iprot):
7783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7785 
      return
7786 
    iprot.readStructBegin()
7787 
    while True:
7788 
      (fname, ftype, fid) = iprot.readFieldBegin()
7789 
      if ftype == TType.STOP:
7790 
        break
7791 
      if fid == 1:
7792 
        if ftype == TType.I64:
3064 chandransh 7793 
          self.transactionId = iprot.readI64();
494 rajveer 7794 
        else:
7795 
          iprot.skip(ftype)
7796 
      elif fid == 2:
3064 chandransh 7797 
        if ftype == TType.I64:
7798 
          self.customerId = iprot.readI64();
494 rajveer 7799 
        else:
7800 
          iprot.skip(ftype)
7801 
      else:
7802 
        iprot.skip(ftype)
7803 
      iprot.readFieldEnd()
7804 
    iprot.readStructEnd()
7805 
 
7806 
  def write(self, oprot):
7807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7809 
      return
3064 chandransh 7810 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7811 
    if self.transactionId is not None:
3064 chandransh 7812 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7813 
      oprot.writeI64(self.transactionId)
494 rajveer 7814 
      oprot.writeFieldEnd()
3431 rajveer 7815 
    if self.customerId is not None:
3064 chandransh 7816 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7817 
      oprot.writeI64(self.customerId)
494 rajveer 7818 
      oprot.writeFieldEnd()
7819 
    oprot.writeFieldStop()
7820 
    oprot.writeStructEnd()
7821 
 
3431 rajveer 7822 
  def validate(self):
7823 
    return
7824 
 
7825 
 
494 rajveer 7826 
  def __repr__(self):
7827 
    L = ['%s=%r' % (key, value)
7828 
      for key, value in self.__dict__.iteritems()]
7829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7830 
 
7831 
  def __eq__(self, other):
7832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7833 
 
7834 
  def __ne__(self, other):
7835 
    return not (self == other)
7836 
 
3064 chandransh 7837 
class getOrdersForTransaction_result:
494 rajveer 7838 
  """
7839 
  Attributes:
7840 
   - success
7841 
   - ex
7842 
  """
7843 
 
7844 
  thrift_spec = (
3064 chandransh 7845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7847 
  )
7848 
 
7849 
  def __init__(self, success=None, ex=None,):
7850 
    self.success = success
7851 
    self.ex = ex
7852 
 
7853 
  def read(self, iprot):
7854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7856 
      return
7857 
    iprot.readStructBegin()
7858 
    while True:
7859 
      (fname, ftype, fid) = iprot.readFieldBegin()
7860 
      if ftype == TType.STOP:
7861 
        break
7862 
      if fid == 0:
3064 chandransh 7863 
        if ftype == TType.LIST:
7864 
          self.success = []
4133 chandransh 7865 
          (_etype87, _size84) = iprot.readListBegin()
7866 
          for _i88 in xrange(_size84):
7867 
            _elem89 = Order()
7868 
            _elem89.read(iprot)
7869 
            self.success.append(_elem89)
3064 chandransh 7870 
          iprot.readListEnd()
494 rajveer 7871 
        else:
7872 
          iprot.skip(ftype)
7873 
      elif fid == 1:
7874 
        if ftype == TType.STRUCT:
7875 
          self.ex = TransactionServiceException()
7876 
          self.ex.read(iprot)
7877 
        else:
7878 
          iprot.skip(ftype)
7879 
      else:
7880 
        iprot.skip(ftype)
7881 
      iprot.readFieldEnd()
7882 
    iprot.readStructEnd()
7883 
 
7884 
  def write(self, oprot):
7885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7887 
      return
3064 chandransh 7888 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7889 
    if self.success is not None:
3064 chandransh 7890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7892 
      for iter90 in self.success:
7893 
        iter90.write(oprot)
3064 chandransh 7894 
      oprot.writeListEnd()
494 rajveer 7895 
      oprot.writeFieldEnd()
3431 rajveer 7896 
    if self.ex is not None:
494 rajveer 7897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7898 
      self.ex.write(oprot)
7899 
      oprot.writeFieldEnd()
7900 
    oprot.writeFieldStop()
7901 
    oprot.writeStructEnd()
7902 
 
3431 rajveer 7903 
  def validate(self):
7904 
    return
7905 
 
7906 
 
494 rajveer 7907 
  def __repr__(self):
7908 
    L = ['%s=%r' % (key, value)
7909 
      for key, value in self.__dict__.iteritems()]
7910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7911 
 
7912 
  def __eq__(self, other):
7913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7914 
 
7915 
  def __ne__(self, other):
7916 
    return not (self == other)
7917 
 
3064 chandransh 7918 
class getOrdersForCustomer_args:
1149 chandransh 7919 
  """
7920 
  Attributes:
3064 chandransh 7921 
   - customerId
7922 
   - from_date
7923 
   - to_date
7924 
   - statuses
1149 chandransh 7925 
  """
7926 
 
7927 
  thrift_spec = (
7928 
    None, # 0
3064 chandransh 7929 
    (1, TType.I64, 'customerId', None, None, ), # 1
7930 
    (2, TType.I64, 'from_date', None, None, ), # 2
7931 
    (3, TType.I64, 'to_date', None, None, ), # 3
7932 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7933 
  )
7934 
 
3064 chandransh 7935 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7936 
    self.customerId = customerId
7937 
    self.from_date = from_date
7938 
    self.to_date = to_date
7939 
    self.statuses = statuses
1149 chandransh 7940 
 
7941 
  def read(self, iprot):
7942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7944 
      return
7945 
    iprot.readStructBegin()
7946 
    while True:
7947 
      (fname, ftype, fid) = iprot.readFieldBegin()
7948 
      if ftype == TType.STOP:
7949 
        break
7950 
      if fid == 1:
7951 
        if ftype == TType.I64:
3064 chandransh 7952 
          self.customerId = iprot.readI64();
1149 chandransh 7953 
        else:
7954 
          iprot.skip(ftype)
7955 
      elif fid == 2:
7956 
        if ftype == TType.I64:
3064 chandransh 7957 
          self.from_date = iprot.readI64();
1149 chandransh 7958 
        else:
7959 
          iprot.skip(ftype)
2783 chandransh 7960 
      elif fid == 3:
7961 
        if ftype == TType.I64:
3064 chandransh 7962 
          self.to_date = iprot.readI64();
2783 chandransh 7963 
        else:
7964 
          iprot.skip(ftype)
7965 
      elif fid == 4:
3064 chandransh 7966 
        if ftype == TType.LIST:
7967 
          self.statuses = []
4133 chandransh 7968 
          (_etype94, _size91) = iprot.readListBegin()
7969 
          for _i95 in xrange(_size91):
7970 
            _elem96 = iprot.readI32();
7971 
            self.statuses.append(_elem96)
3064 chandransh 7972 
          iprot.readListEnd()
2783 chandransh 7973 
        else:
7974 
          iprot.skip(ftype)
1149 chandransh 7975 
      else:
7976 
        iprot.skip(ftype)
7977 
      iprot.readFieldEnd()
7978 
    iprot.readStructEnd()
7979 
 
7980 
  def write(self, oprot):
7981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7983 
      return
3064 chandransh 7984 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7985 
    if self.customerId is not None:
3064 chandransh 7986 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7987 
      oprot.writeI64(self.customerId)
1149 chandransh 7988 
      oprot.writeFieldEnd()
3431 rajveer 7989 
    if self.from_date is not None:
3064 chandransh 7990 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7991 
      oprot.writeI64(self.from_date)
1149 chandransh 7992 
      oprot.writeFieldEnd()
3431 rajveer 7993 
    if self.to_date is not None:
3064 chandransh 7994 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7995 
      oprot.writeI64(self.to_date)
2783 chandransh 7996 
      oprot.writeFieldEnd()
3431 rajveer 7997 
    if self.statuses is not None:
3064 chandransh 7998 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7999 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8000 
      for iter97 in self.statuses:
8001 
        oprot.writeI32(iter97)
3064 chandransh 8002 
      oprot.writeListEnd()
2783 chandransh 8003 
      oprot.writeFieldEnd()
1149 chandransh 8004 
    oprot.writeFieldStop()
8005 
    oprot.writeStructEnd()
8006 
 
3431 rajveer 8007 
  def validate(self):
8008 
    return
8009 
 
8010 
 
1149 chandransh 8011 
  def __repr__(self):
8012 
    L = ['%s=%r' % (key, value)
8013 
      for key, value in self.__dict__.iteritems()]
8014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8015 
 
8016 
  def __eq__(self, other):
8017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8018 
 
8019 
  def __ne__(self, other):
8020 
    return not (self == other)
8021 
 
3064 chandransh 8022 
class getOrdersForCustomer_result:
1149 chandransh 8023 
  """
8024 
  Attributes:
8025 
   - success
8026 
   - ex
8027 
  """
8028 
 
8029 
  thrift_spec = (
3064 chandransh 8030 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8032 
  )
8033 
 
8034 
  def __init__(self, success=None, ex=None,):
8035 
    self.success = success
8036 
    self.ex = ex
8037 
 
8038 
  def read(self, iprot):
8039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8041 
      return
8042 
    iprot.readStructBegin()
8043 
    while True:
8044 
      (fname, ftype, fid) = iprot.readFieldBegin()
8045 
      if ftype == TType.STOP:
8046 
        break
8047 
      if fid == 0:
3064 chandransh 8048 
        if ftype == TType.LIST:
8049 
          self.success = []
4133 chandransh 8050 
          (_etype101, _size98) = iprot.readListBegin()
8051 
          for _i102 in xrange(_size98):
8052 
            _elem103 = Order()
8053 
            _elem103.read(iprot)
8054 
            self.success.append(_elem103)
3064 chandransh 8055 
          iprot.readListEnd()
1149 chandransh 8056 
        else:
8057 
          iprot.skip(ftype)
8058 
      elif fid == 1:
8059 
        if ftype == TType.STRUCT:
8060 
          self.ex = TransactionServiceException()
8061 
          self.ex.read(iprot)
8062 
        else:
8063 
          iprot.skip(ftype)
8064 
      else:
8065 
        iprot.skip(ftype)
8066 
      iprot.readFieldEnd()
8067 
    iprot.readStructEnd()
8068 
 
8069 
  def write(self, oprot):
8070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8072 
      return
3064 chandransh 8073 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8074 
    if self.success is not None:
3064 chandransh 8075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8076 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8077 
      for iter104 in self.success:
8078 
        iter104.write(oprot)
3064 chandransh 8079 
      oprot.writeListEnd()
1149 chandransh 8080 
      oprot.writeFieldEnd()
3431 rajveer 8081 
    if self.ex is not None:
1149 chandransh 8082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8083 
      self.ex.write(oprot)
8084 
      oprot.writeFieldEnd()
8085 
    oprot.writeFieldStop()
8086 
    oprot.writeStructEnd()
8087 
 
3431 rajveer 8088 
  def validate(self):
8089 
    return
8090 
 
8091 
 
1149 chandransh 8092 
  def __repr__(self):
8093 
    L = ['%s=%r' % (key, value)
8094 
      for key, value in self.__dict__.iteritems()]
8095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8096 
 
8097 
  def __eq__(self, other):
8098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8099 
 
8100 
  def __ne__(self, other):
8101 
    return not (self == other)
8102 
 
3064 chandransh 8103 
class createOrder_args:
921 rajveer 8104 
  """
8105 
  Attributes:
3064 chandransh 8106 
   - order
921 rajveer 8107 
  """
8108 
 
8109 
  thrift_spec = (
8110 
    None, # 0
3064 chandransh 8111 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8112 
  )
8113 
 
3064 chandransh 8114 
  def __init__(self, order=None,):
8115 
    self.order = order
921 rajveer 8116 
 
8117 
  def read(self, iprot):
8118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8120 
      return
8121 
    iprot.readStructBegin()
8122 
    while True:
8123 
      (fname, ftype, fid) = iprot.readFieldBegin()
8124 
      if ftype == TType.STOP:
8125 
        break
8126 
      if fid == 1:
3064 chandransh 8127 
        if ftype == TType.STRUCT:
8128 
          self.order = Order()
8129 
          self.order.read(iprot)
921 rajveer 8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      else:
8133 
        iprot.skip(ftype)
8134 
      iprot.readFieldEnd()
8135 
    iprot.readStructEnd()
8136 
 
8137 
  def write(self, oprot):
8138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8140 
      return
3064 chandransh 8141 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8142 
    if self.order is not None:
3064 chandransh 8143 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8144 
      self.order.write(oprot)
921 rajveer 8145 
      oprot.writeFieldEnd()
8146 
    oprot.writeFieldStop()
8147 
    oprot.writeStructEnd()
8148 
 
3431 rajveer 8149 
  def validate(self):
8150 
    return
8151 
 
8152 
 
921 rajveer 8153 
  def __repr__(self):
8154 
    L = ['%s=%r' % (key, value)
8155 
      for key, value in self.__dict__.iteritems()]
8156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8157 
 
8158 
  def __eq__(self, other):
8159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8160 
 
8161 
  def __ne__(self, other):
8162 
    return not (self == other)
8163 
 
3064 chandransh 8164 
class createOrder_result:
921 rajveer 8165 
  """
8166 
  Attributes:
8167 
   - success
8168 
   - ex
8169 
  """
8170 
 
8171 
  thrift_spec = (
3064 chandransh 8172 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8174 
  )
8175 
 
8176 
  def __init__(self, success=None, ex=None,):
8177 
    self.success = success
8178 
    self.ex = ex
8179 
 
8180 
  def read(self, iprot):
8181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8183 
      return
8184 
    iprot.readStructBegin()
8185 
    while True:
8186 
      (fname, ftype, fid) = iprot.readFieldBegin()
8187 
      if ftype == TType.STOP:
8188 
        break
8189 
      if fid == 0:
3064 chandransh 8190 
        if ftype == TType.I64:
8191 
          self.success = iprot.readI64();
921 rajveer 8192 
        else:
8193 
          iprot.skip(ftype)
8194 
      elif fid == 1:
8195 
        if ftype == TType.STRUCT:
8196 
          self.ex = TransactionServiceException()
8197 
          self.ex.read(iprot)
8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
3064 chandransh 8209 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8210 
    if self.success is not None:
3064 chandransh 8211 
      oprot.writeFieldBegin('success', TType.I64, 0)
8212 
      oprot.writeI64(self.success)
921 rajveer 8213 
      oprot.writeFieldEnd()
3431 rajveer 8214 
    if self.ex is not None:
921 rajveer 8215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8216 
      self.ex.write(oprot)
8217 
      oprot.writeFieldEnd()
8218 
    oprot.writeFieldStop()
8219 
    oprot.writeStructEnd()
8220 
 
3431 rajveer 8221 
  def validate(self):
8222 
    return
8223 
 
8224 
 
921 rajveer 8225 
  def __repr__(self):
8226 
    L = ['%s=%r' % (key, value)
8227 
      for key, value in self.__dict__.iteritems()]
8228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8229 
 
8230 
  def __eq__(self, other):
8231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8232 
 
8233 
  def __ne__(self, other):
8234 
    return not (self == other)
8235 
 
3064 chandransh 8236 
class getOrder_args:
921 rajveer 8237 
  """
8238 
  Attributes:
3064 chandransh 8239 
   - id
921 rajveer 8240 
  """
8241 
 
8242 
  thrift_spec = (
8243 
    None, # 0
3064 chandransh 8244 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8245 
  )
8246 
 
3064 chandransh 8247 
  def __init__(self, id=None,):
8248 
    self.id = id
921 rajveer 8249 
 
8250 
  def read(self, iprot):
8251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8253 
      return
8254 
    iprot.readStructBegin()
8255 
    while True:
8256 
      (fname, ftype, fid) = iprot.readFieldBegin()
8257 
      if ftype == TType.STOP:
8258 
        break
8259 
      if fid == 1:
8260 
        if ftype == TType.I64:
3064 chandransh 8261 
          self.id = iprot.readI64();
921 rajveer 8262 
        else:
8263 
          iprot.skip(ftype)
8264 
      else:
8265 
        iprot.skip(ftype)
8266 
      iprot.readFieldEnd()
8267 
    iprot.readStructEnd()
8268 
 
8269 
  def write(self, oprot):
8270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8272 
      return
3064 chandransh 8273 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8274 
    if self.id is not None:
3064 chandransh 8275 
      oprot.writeFieldBegin('id', TType.I64, 1)
8276 
      oprot.writeI64(self.id)
921 rajveer 8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
3431 rajveer 8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
921 rajveer 8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
3064 chandransh 8296 
class getOrder_result:
921 rajveer 8297 
  """
8298 
  Attributes:
8299 
   - success
8300 
   - ex
8301 
  """
8302 
 
8303 
  thrift_spec = (
3064 chandransh 8304 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8306 
  )
8307 
 
8308 
  def __init__(self, success=None, ex=None,):
8309 
    self.success = success
8310 
    self.ex = ex
8311 
 
8312 
  def read(self, iprot):
8313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8315 
      return
8316 
    iprot.readStructBegin()
8317 
    while True:
8318 
      (fname, ftype, fid) = iprot.readFieldBegin()
8319 
      if ftype == TType.STOP:
8320 
        break
8321 
      if fid == 0:
3064 chandransh 8322 
        if ftype == TType.STRUCT:
8323 
          self.success = Order()
8324 
          self.success.read(iprot)
921 rajveer 8325 
        else:
8326 
          iprot.skip(ftype)
8327 
      elif fid == 1:
8328 
        if ftype == TType.STRUCT:
8329 
          self.ex = TransactionServiceException()
8330 
          self.ex.read(iprot)
8331 
        else:
8332 
          iprot.skip(ftype)
8333 
      else:
8334 
        iprot.skip(ftype)
8335 
      iprot.readFieldEnd()
8336 
    iprot.readStructEnd()
8337 
 
8338 
  def write(self, oprot):
8339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8341 
      return
3064 chandransh 8342 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8343 
    if self.success is not None:
3064 chandransh 8344 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8345 
      self.success.write(oprot)
921 rajveer 8346 
      oprot.writeFieldEnd()
3431 rajveer 8347 
    if self.ex is not None:
921 rajveer 8348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8349 
      self.ex.write(oprot)
8350 
      oprot.writeFieldEnd()
8351 
    oprot.writeFieldStop()
8352 
    oprot.writeStructEnd()
8353 
 
3431 rajveer 8354 
  def validate(self):
8355 
    return
8356 
 
8357 
 
921 rajveer 8358 
  def __repr__(self):
8359 
    L = ['%s=%r' % (key, value)
8360 
      for key, value in self.__dict__.iteritems()]
8361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8362 
 
8363 
  def __eq__(self, other):
8364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8365 
 
8366 
  def __ne__(self, other):
8367 
    return not (self == other)
8368 
 
3064 chandransh 8369 
class getLineItemsForOrder_args:
94 ashish 8370 
  """
8371 
  Attributes:
3064 chandransh 8372 
   - orderId
94 ashish 8373 
  """
8374 
 
8375 
  thrift_spec = (
8376 
    None, # 0
3064 chandransh 8377 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8378 
  )
8379 
 
3064 chandransh 8380 
  def __init__(self, orderId=None,):
8381 
    self.orderId = orderId
94 ashish 8382 
 
8383 
  def read(self, iprot):
8384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8386 
      return
8387 
    iprot.readStructBegin()
8388 
    while True:
8389 
      (fname, ftype, fid) = iprot.readFieldBegin()
8390 
      if ftype == TType.STOP:
8391 
        break
8392 
      if fid == 1:
8393 
        if ftype == TType.I64:
3064 chandransh 8394 
          self.orderId = iprot.readI64();
94 ashish 8395 
        else:
8396 
          iprot.skip(ftype)
8397 
      else:
8398 
        iprot.skip(ftype)
8399 
      iprot.readFieldEnd()
8400 
    iprot.readStructEnd()
8401 
 
8402 
  def write(self, oprot):
8403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8405 
      return
3064 chandransh 8406 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8407 
    if self.orderId is not None:
3064 chandransh 8408 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8409 
      oprot.writeI64(self.orderId)
94 ashish 8410 
      oprot.writeFieldEnd()
8411 
    oprot.writeFieldStop()
8412 
    oprot.writeStructEnd()
8413 
 
3431 rajveer 8414 
  def validate(self):
8415 
    return
8416 
 
8417 
 
94 ashish 8418 
  def __repr__(self):
8419 
    L = ['%s=%r' % (key, value)
8420 
      for key, value in self.__dict__.iteritems()]
8421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8422 
 
8423 
  def __eq__(self, other):
8424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8425 
 
8426 
  def __ne__(self, other):
8427 
    return not (self == other)
8428 
 
3064 chandransh 8429 
class getLineItemsForOrder_result:
94 ashish 8430 
  """
8431 
  Attributes:
8432 
   - success
8433 
   - ex
8434 
  """
8435 
 
8436 
  thrift_spec = (
3064 chandransh 8437 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8438 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8439 
  )
8440 
 
8441 
  def __init__(self, success=None, ex=None,):
8442 
    self.success = success
8443 
    self.ex = ex
8444 
 
8445 
  def read(self, iprot):
8446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8448 
      return
8449 
    iprot.readStructBegin()
8450 
    while True:
8451 
      (fname, ftype, fid) = iprot.readFieldBegin()
8452 
      if ftype == TType.STOP:
8453 
        break
8454 
      if fid == 0:
483 rajveer 8455 
        if ftype == TType.LIST:
8456 
          self.success = []
4133 chandransh 8457 
          (_etype108, _size105) = iprot.readListBegin()
8458 
          for _i109 in xrange(_size105):
8459 
            _elem110 = LineItem()
8460 
            _elem110.read(iprot)
8461 
            self.success.append(_elem110)
483 rajveer 8462 
          iprot.readListEnd()
94 ashish 8463 
        else:
8464 
          iprot.skip(ftype)
8465 
      elif fid == 1:
8466 
        if ftype == TType.STRUCT:
8467 
          self.ex = TransactionServiceException()
8468 
          self.ex.read(iprot)
8469 
        else:
8470 
          iprot.skip(ftype)
8471 
      else:
8472 
        iprot.skip(ftype)
8473 
      iprot.readFieldEnd()
8474 
    iprot.readStructEnd()
8475 
 
8476 
  def write(self, oprot):
8477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8479 
      return
3064 chandransh 8480 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8481 
    if self.success is not None:
483 rajveer 8482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8484 
      for iter111 in self.success:
8485 
        iter111.write(oprot)
483 rajveer 8486 
      oprot.writeListEnd()
94 ashish 8487 
      oprot.writeFieldEnd()
3431 rajveer 8488 
    if self.ex is not None:
94 ashish 8489 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8490 
      self.ex.write(oprot)
8491 
      oprot.writeFieldEnd()
8492 
    oprot.writeFieldStop()
8493 
    oprot.writeStructEnd()
8494 
 
3431 rajveer 8495 
  def validate(self):
8496 
    return
8497 
 
8498 
 
94 ashish 8499 
  def __repr__(self):
8500 
    L = ['%s=%r' % (key, value)
8501 
      for key, value in self.__dict__.iteritems()]
8502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8503 
 
8504 
  def __eq__(self, other):
8505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8506 
 
8507 
  def __ne__(self, other):
8508 
    return not (self == other)
8509 
 
3064 chandransh 8510 
class getOrderForCustomer_args:
94 ashish 8511 
  """
8512 
  Attributes:
3064 chandransh 8513 
   - orderId
483 rajveer 8514 
   - customerId
94 ashish 8515 
  """
8516 
 
8517 
  thrift_spec = (
8518 
    None, # 0
3064 chandransh 8519 
    (1, TType.I64, 'orderId', None, None, ), # 1
8520 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8521 
  )
8522 
 
3064 chandransh 8523 
  def __init__(self, orderId=None, customerId=None,):
8524 
    self.orderId = orderId
483 rajveer 8525 
    self.customerId = customerId
94 ashish 8526 
 
8527 
  def read(self, iprot):
8528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8530 
      return
8531 
    iprot.readStructBegin()
8532 
    while True:
8533 
      (fname, ftype, fid) = iprot.readFieldBegin()
8534 
      if ftype == TType.STOP:
8535 
        break
8536 
      if fid == 1:
8537 
        if ftype == TType.I64:
3064 chandransh 8538 
          self.orderId = iprot.readI64();
94 ashish 8539 
        else:
8540 
          iprot.skip(ftype)
8541 
      elif fid == 2:
8542 
        if ftype == TType.I64:
3064 chandransh 8543 
          self.customerId = iprot.readI64();
94 ashish 8544 
        else:
8545 
          iprot.skip(ftype)
8546 
      else:
8547 
        iprot.skip(ftype)
8548 
      iprot.readFieldEnd()
8549 
    iprot.readStructEnd()
8550 
 
8551 
  def write(self, oprot):
8552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8554 
      return
3064 chandransh 8555 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8556 
    if self.orderId is not None:
3064 chandransh 8557 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8558 
      oprot.writeI64(self.orderId)
8559 
      oprot.writeFieldEnd()
3431 rajveer 8560 
    if self.customerId is not None:
3064 chandransh 8561 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8562 
      oprot.writeI64(self.customerId)
94 ashish 8563 
      oprot.writeFieldEnd()
8564 
    oprot.writeFieldStop()
8565 
    oprot.writeStructEnd()
8566 
 
3431 rajveer 8567 
  def validate(self):
8568 
    return
8569 
 
8570 
 
94 ashish 8571 
  def __repr__(self):
8572 
    L = ['%s=%r' % (key, value)
8573 
      for key, value in self.__dict__.iteritems()]
8574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8575 
 
8576 
  def __eq__(self, other):
8577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8578 
 
8579 
  def __ne__(self, other):
8580 
    return not (self == other)
8581 
 
3064 chandransh 8582 
class getOrderForCustomer_result:
94 ashish 8583 
  """
8584 
  Attributes:
8585 
   - success
8586 
   - ex
8587 
  """
8588 
 
8589 
  thrift_spec = (
3064 chandransh 8590 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8592 
  )
8593 
 
8594 
  def __init__(self, success=None, ex=None,):
8595 
    self.success = success
8596 
    self.ex = ex
8597 
 
8598 
  def read(self, iprot):
8599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8601 
      return
8602 
    iprot.readStructBegin()
8603 
    while True:
8604 
      (fname, ftype, fid) = iprot.readFieldBegin()
8605 
      if ftype == TType.STOP:
8606 
        break
8607 
      if fid == 0:
3064 chandransh 8608 
        if ftype == TType.STRUCT:
8609 
          self.success = Order()
8610 
          self.success.read(iprot)
94 ashish 8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      elif fid == 1:
8614 
        if ftype == TType.STRUCT:
8615 
          self.ex = TransactionServiceException()
8616 
          self.ex.read(iprot)
8617 
        else:
8618 
          iprot.skip(ftype)
8619 
      else:
8620 
        iprot.skip(ftype)
8621 
      iprot.readFieldEnd()
8622 
    iprot.readStructEnd()
8623 
 
8624 
  def write(self, oprot):
8625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8627 
      return
3064 chandransh 8628 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8629 
    if self.success is not None:
3064 chandransh 8630 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8631 
      self.success.write(oprot)
94 ashish 8632 
      oprot.writeFieldEnd()
3431 rajveer 8633 
    if self.ex is not None:
94 ashish 8634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8635 
      self.ex.write(oprot)
8636 
      oprot.writeFieldEnd()
8637 
    oprot.writeFieldStop()
8638 
    oprot.writeStructEnd()
8639 
 
3431 rajveer 8640 
  def validate(self):
8641 
    return
8642 
 
8643 
 
94 ashish 8644 
  def __repr__(self):
8645 
    L = ['%s=%r' % (key, value)
8646 
      for key, value in self.__dict__.iteritems()]
8647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8648 
 
8649 
  def __eq__(self, other):
8650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8651 
 
8652 
  def __ne__(self, other):
8653 
    return not (self == other)
8654 
 
3064 chandransh 8655 
class getAlerts_args:
94 ashish 8656 
  """
8657 
  Attributes:
4394 rajveer 8658 
   - type
4444 rajveer 8659 
   - warehouseId
4394 rajveer 8660 
   - status
8661 
   - timestamp
94 ashish 8662 
  """
8663 
 
8664 
  thrift_spec = (
8665 
    None, # 0
4394 rajveer 8666 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8667 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8668 
    (3, TType.I64, 'status', None, None, ), # 3
8669 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8670 
  )
8671 
 
4444 rajveer 8672 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8673 
    self.type = type
4444 rajveer 8674 
    self.warehouseId = warehouseId
4394 rajveer 8675 
    self.status = status
8676 
    self.timestamp = timestamp
94 ashish 8677 
 
8678 
  def read(self, iprot):
8679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8681 
      return
8682 
    iprot.readStructBegin()
8683 
    while True:
8684 
      (fname, ftype, fid) = iprot.readFieldBegin()
8685 
      if ftype == TType.STOP:
8686 
        break
8687 
      if fid == 1:
3064 chandransh 8688 
        if ftype == TType.I64:
4394 rajveer 8689 
          self.type = iprot.readI64();
94 ashish 8690 
        else:
8691 
          iprot.skip(ftype)
3064 chandransh 8692 
      elif fid == 2:
4394 rajveer 8693 
        if ftype == TType.I64:
4444 rajveer 8694 
          self.warehouseId = iprot.readI64();
3064 chandransh 8695 
        else:
8696 
          iprot.skip(ftype)
4394 rajveer 8697 
      elif fid == 3:
8698 
        if ftype == TType.I64:
4444 rajveer 8699 
          self.status = iprot.readI64();
8700 
        else:
8701 
          iprot.skip(ftype)
8702 
      elif fid == 4:
8703 
        if ftype == TType.I64:
4394 rajveer 8704 
          self.timestamp = iprot.readI64();
8705 
        else:
8706 
          iprot.skip(ftype)
94 ashish 8707 
      else:
8708 
        iprot.skip(ftype)
8709 
      iprot.readFieldEnd()
8710 
    iprot.readStructEnd()
8711 
 
8712 
  def write(self, oprot):
8713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8715 
      return
3064 chandransh 8716 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8717 
    if self.type is not None:
8718 
      oprot.writeFieldBegin('type', TType.I64, 1)
8719 
      oprot.writeI64(self.type)
94 ashish 8720 
      oprot.writeFieldEnd()
4444 rajveer 8721 
    if self.warehouseId is not None:
8722 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8723 
      oprot.writeI64(self.warehouseId)
8724 
      oprot.writeFieldEnd()
4394 rajveer 8725 
    if self.status is not None:
4444 rajveer 8726 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8727 
      oprot.writeI64(self.status)
3064 chandransh 8728 
      oprot.writeFieldEnd()
4394 rajveer 8729 
    if self.timestamp is not None:
4444 rajveer 8730 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8731 
      oprot.writeI64(self.timestamp)
8732 
      oprot.writeFieldEnd()
94 ashish 8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
3431 rajveer 8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
94 ashish 8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
3064 chandransh 8751 
class getAlerts_result:
94 ashish 8752 
  """
8753 
  Attributes:
8754 
   - success
8755 
  """
8756 
 
8757 
  thrift_spec = (
3064 chandransh 8758 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8759 
  )
8760 
 
3064 chandransh 8761 
  def __init__(self, success=None,):
94 ashish 8762 
    self.success = success
8763 
 
8764 
  def read(self, iprot):
8765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8767 
      return
8768 
    iprot.readStructBegin()
8769 
    while True:
8770 
      (fname, ftype, fid) = iprot.readFieldBegin()
8771 
      if ftype == TType.STOP:
8772 
        break
8773 
      if fid == 0:
3064 chandransh 8774 
        if ftype == TType.LIST:
8775 
          self.success = []
4133 chandransh 8776 
          (_etype115, _size112) = iprot.readListBegin()
8777 
          for _i116 in xrange(_size112):
8778 
            _elem117 = Alert()
8779 
            _elem117.read(iprot)
8780 
            self.success.append(_elem117)
3064 chandransh 8781 
          iprot.readListEnd()
94 ashish 8782 
        else:
8783 
          iprot.skip(ftype)
8784 
      else:
8785 
        iprot.skip(ftype)
8786 
      iprot.readFieldEnd()
8787 
    iprot.readStructEnd()
8788 
 
8789 
  def write(self, oprot):
8790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8792 
      return
3064 chandransh 8793 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8794 
    if self.success is not None:
3064 chandransh 8795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8797 
      for iter118 in self.success:
8798 
        iter118.write(oprot)
3064 chandransh 8799 
      oprot.writeListEnd()
94 ashish 8800 
      oprot.writeFieldEnd()
8801 
    oprot.writeFieldStop()
8802 
    oprot.writeStructEnd()
8803 
 
3431 rajveer 8804 
  def validate(self):
8805 
    return
8806 
 
8807 
 
94 ashish 8808 
  def __repr__(self):
8809 
    L = ['%s=%r' % (key, value)
8810 
      for key, value in self.__dict__.iteritems()]
8811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8812 
 
8813 
  def __eq__(self, other):
8814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8815 
 
8816 
  def __ne__(self, other):
8817 
    return not (self == other)
8818 
 
4394 rajveer 8819 
class addAlert_args:
94 ashish 8820 
  """
8821 
  Attributes:
3064 chandransh 8822 
   - type
4444 rajveer 8823 
   - warehouseId
4394 rajveer 8824 
   - description
94 ashish 8825 
  """
8826 
 
8827 
  thrift_spec = (
8828 
    None, # 0
4394 rajveer 8829 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8830 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8831 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8832 
  )
8833 
 
4444 rajveer 8834 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8835 
    self.type = type
4444 rajveer 8836 
    self.warehouseId = warehouseId
4394 rajveer 8837 
    self.description = description
94 ashish 8838 
 
8839 
  def read(self, iprot):
8840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8842 
      return
8843 
    iprot.readStructBegin()
8844 
    while True:
8845 
      (fname, ftype, fid) = iprot.readFieldBegin()
8846 
      if ftype == TType.STOP:
8847 
        break
8848 
      if fid == 1:
8849 
        if ftype == TType.I64:
4394 rajveer 8850 
          self.type = iprot.readI64();
94 ashish 8851 
        else:
8852 
          iprot.skip(ftype)
3064 chandransh 8853 
      elif fid == 2:
4444 rajveer 8854 
        if ftype == TType.I64:
8855 
          self.warehouseId = iprot.readI64();
8856 
        else:
8857 
          iprot.skip(ftype)
8858 
      elif fid == 3:
3064 chandransh 8859 
        if ftype == TType.STRING:
4394 rajveer 8860 
          self.description = iprot.readString();
3064 chandransh 8861 
        else:
8862 
          iprot.skip(ftype)
94 ashish 8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
4394 rajveer 8872 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8873 
    if self.type is not None:
4394 rajveer 8874 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8875 
      oprot.writeI64(self.type)
8876 
      oprot.writeFieldEnd()
4444 rajveer 8877 
    if self.warehouseId is not None:
8878 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8879 
      oprot.writeI64(self.warehouseId)
8880 
      oprot.writeFieldEnd()
4394 rajveer 8881 
    if self.description is not None:
4444 rajveer 8882 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8883 
      oprot.writeString(self.description)
3064 chandransh 8884 
      oprot.writeFieldEnd()
94 ashish 8885 
    oprot.writeFieldStop()
8886 
    oprot.writeStructEnd()
8887 
 
3431 rajveer 8888 
  def validate(self):
8889 
    return
8890 
 
8891 
 
94 ashish 8892 
  def __repr__(self):
8893 
    L = ['%s=%r' % (key, value)
8894 
      for key, value in self.__dict__.iteritems()]
8895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8896 
 
8897 
  def __eq__(self, other):
8898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8899 
 
8900 
  def __ne__(self, other):
8901 
    return not (self == other)
8902 
 
4394 rajveer 8903 
class addAlert_result:
3064 chandransh 8904 
 
8905 
  thrift_spec = (
8906 
  )
8907 
 
8908 
  def read(self, iprot):
8909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8911 
      return
8912 
    iprot.readStructBegin()
8913 
    while True:
8914 
      (fname, ftype, fid) = iprot.readFieldBegin()
8915 
      if ftype == TType.STOP:
8916 
        break
8917 
      else:
8918 
        iprot.skip(ftype)
8919 
      iprot.readFieldEnd()
8920 
    iprot.readStructEnd()
8921 
 
8922 
  def write(self, oprot):
8923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8925 
      return
4394 rajveer 8926 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8927 
    oprot.writeFieldStop()
8928 
    oprot.writeStructEnd()
8929 
 
3431 rajveer 8930 
  def validate(self):
8931 
    return
8932 
 
8933 
 
3064 chandransh 8934 
  def __repr__(self):
8935 
    L = ['%s=%r' % (key, value)
8936 
      for key, value in self.__dict__.iteritems()]
8937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8938 
 
8939 
  def __eq__(self, other):
8940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8941 
 
8942 
  def __ne__(self, other):
8943 
    return not (self == other)
8944 
 
4444 rajveer 8945 
class markAlertsAsSeen_args:
8946 
  """
8947 
  Attributes:
8948 
   - warehouseId
8949 
  """
8950 
 
8951 
  thrift_spec = (
8952 
    None, # 0
8953 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8954 
  )
8955 
 
8956 
  def __init__(self, warehouseId=None,):
8957 
    self.warehouseId = warehouseId
8958 
 
8959 
  def read(self, iprot):
8960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8962 
      return
8963 
    iprot.readStructBegin()
8964 
    while True:
8965 
      (fname, ftype, fid) = iprot.readFieldBegin()
8966 
      if ftype == TType.STOP:
8967 
        break
8968 
      if fid == 1:
8969 
        if ftype == TType.I64:
8970 
          self.warehouseId = iprot.readI64();
8971 
        else:
8972 
          iprot.skip(ftype)
8973 
      else:
8974 
        iprot.skip(ftype)
8975 
      iprot.readFieldEnd()
8976 
    iprot.readStructEnd()
8977 
 
8978 
  def write(self, oprot):
8979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8981 
      return
8982 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8983 
    if self.warehouseId is not None:
8984 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8985 
      oprot.writeI64(self.warehouseId)
8986 
      oprot.writeFieldEnd()
8987 
    oprot.writeFieldStop()
8988 
    oprot.writeStructEnd()
8989 
 
8990 
  def validate(self):
8991 
    return
8992 
 
8993 
 
8994 
  def __repr__(self):
8995 
    L = ['%s=%r' % (key, value)
8996 
      for key, value in self.__dict__.iteritems()]
8997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8998 
 
8999 
  def __eq__(self, other):
9000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9001 
 
9002 
  def __ne__(self, other):
9003 
    return not (self == other)
9004 
 
9005 
class markAlertsAsSeen_result:
9006 
 
9007 
  thrift_spec = (
9008 
  )
9009 
 
9010 
  def read(self, iprot):
9011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9013 
      return
9014 
    iprot.readStructBegin()
9015 
    while True:
9016 
      (fname, ftype, fid) = iprot.readFieldBegin()
9017 
      if ftype == TType.STOP:
9018 
        break
9019 
      else:
9020 
        iprot.skip(ftype)
9021 
      iprot.readFieldEnd()
9022 
    iprot.readStructEnd()
9023 
 
9024 
  def write(self, oprot):
9025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9027 
      return
9028 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9029 
    oprot.writeFieldStop()
9030 
    oprot.writeStructEnd()
9031 
 
9032 
  def validate(self):
9033 
    return
9034 
 
9035 
 
9036 
  def __repr__(self):
9037 
    L = ['%s=%r' % (key, value)
9038 
      for key, value in self.__dict__.iteritems()]
9039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9040 
 
9041 
  def __eq__(self, other):
9042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9043 
 
9044 
  def __ne__(self, other):
9045 
    return not (self == other)
9046 
 
3064 chandransh 9047 
class getValidOrderCount_args:
9048 
 
9049 
  thrift_spec = (
9050 
  )
9051 
 
9052 
  def read(self, iprot):
9053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9055 
      return
9056 
    iprot.readStructBegin()
9057 
    while True:
9058 
      (fname, ftype, fid) = iprot.readFieldBegin()
9059 
      if ftype == TType.STOP:
9060 
        break
9061 
      else:
9062 
        iprot.skip(ftype)
9063 
      iprot.readFieldEnd()
9064 
    iprot.readStructEnd()
9065 
 
9066 
  def write(self, oprot):
9067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9069 
      return
9070 
    oprot.writeStructBegin('getValidOrderCount_args')
9071 
    oprot.writeFieldStop()
9072 
    oprot.writeStructEnd()
9073 
 
3431 rajveer 9074 
  def validate(self):
9075 
    return
9076 
 
9077 
 
3064 chandransh 9078 
  def __repr__(self):
9079 
    L = ['%s=%r' % (key, value)
9080 
      for key, value in self.__dict__.iteritems()]
9081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9082 
 
9083 
  def __eq__(self, other):
9084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9085 
 
9086 
  def __ne__(self, other):
9087 
    return not (self == other)
9088 
 
9089 
class getValidOrderCount_result:
94 ashish 9090 
  """
9091 
  Attributes:
9092 
   - success
9093 
  """
9094 
 
9095 
  thrift_spec = (
3064 chandransh 9096 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9097 
  )
9098 
 
3064 chandransh 9099 
  def __init__(self, success=None,):
94 ashish 9100 
    self.success = success
9101 
 
9102 
  def read(self, iprot):
9103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9105 
      return
9106 
    iprot.readStructBegin()
9107 
    while True:
9108 
      (fname, ftype, fid) = iprot.readFieldBegin()
9109 
      if ftype == TType.STOP:
9110 
        break
9111 
      if fid == 0:
3064 chandransh 9112 
        if ftype == TType.I64:
9113 
          self.success = iprot.readI64();
94 ashish 9114 
        else:
9115 
          iprot.skip(ftype)
9116 
      else:
9117 
        iprot.skip(ftype)
9118 
      iprot.readFieldEnd()
9119 
    iprot.readStructEnd()
9120 
 
9121 
  def write(self, oprot):
9122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9124 
      return
3064 chandransh 9125 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9126 
    if self.success is not None:
3064 chandransh 9127 
      oprot.writeFieldBegin('success', TType.I64, 0)
9128 
      oprot.writeI64(self.success)
94 ashish 9129 
      oprot.writeFieldEnd()
9130 
    oprot.writeFieldStop()
9131 
    oprot.writeStructEnd()
9132 
 
3431 rajveer 9133 
  def validate(self):
9134 
    return
9135 
 
9136 
 
94 ashish 9137 
  def __repr__(self):
9138 
    L = ['%s=%r' % (key, value)
9139 
      for key, value in self.__dict__.iteritems()]
9140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9141 
 
9142 
  def __eq__(self, other):
9143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9144 
 
9145 
  def __ne__(self, other):
9146 
    return not (self == other)
9147 
 
3064 chandransh 9148 
class getNoOfCustomersWithSuccessfulTransaction_args:
9149 
 
9150 
  thrift_spec = (
9151 
  )
9152 
 
9153 
  def read(self, iprot):
9154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9156 
      return
9157 
    iprot.readStructBegin()
9158 
    while True:
9159 
      (fname, ftype, fid) = iprot.readFieldBegin()
9160 
      if ftype == TType.STOP:
9161 
        break
9162 
      else:
9163 
        iprot.skip(ftype)
9164 
      iprot.readFieldEnd()
9165 
    iprot.readStructEnd()
9166 
 
9167 
  def write(self, oprot):
9168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9170 
      return
9171 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9172 
    oprot.writeFieldStop()
9173 
    oprot.writeStructEnd()
9174 
 
3431 rajveer 9175 
  def validate(self):
9176 
    return
9177 
 
9178 
 
3064 chandransh 9179 
  def __repr__(self):
9180 
    L = ['%s=%r' % (key, value)
9181 
      for key, value in self.__dict__.iteritems()]
9182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9183 
 
9184 
  def __eq__(self, other):
9185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9186 
 
9187 
  def __ne__(self, other):
9188 
    return not (self == other)
9189 
 
9190 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9191 
  """
9192 
  Attributes:
3064 chandransh 9193 
   - success
94 ashish 9194 
  """
9195 
 
9196 
  thrift_spec = (
3064 chandransh 9197 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9198 
  )
9199 
 
3064 chandransh 9200 
  def __init__(self, success=None,):
9201 
    self.success = success
94 ashish 9202 
 
9203 
  def read(self, iprot):
9204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9206 
      return
9207 
    iprot.readStructBegin()
9208 
    while True:
9209 
      (fname, ftype, fid) = iprot.readFieldBegin()
9210 
      if ftype == TType.STOP:
9211 
        break
3064 chandransh 9212 
      if fid == 0:
94 ashish 9213 
        if ftype == TType.I64:
3064 chandransh 9214 
          self.success = iprot.readI64();
94 ashish 9215 
        else:
9216 
          iprot.skip(ftype)
9217 
      else:
9218 
        iprot.skip(ftype)
9219 
      iprot.readFieldEnd()
9220 
    iprot.readStructEnd()
9221 
 
9222 
  def write(self, oprot):
9223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9225 
      return
3064 chandransh 9226 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9227 
    if self.success is not None:
3064 chandransh 9228 
      oprot.writeFieldBegin('success', TType.I64, 0)
9229 
      oprot.writeI64(self.success)
94 ashish 9230 
      oprot.writeFieldEnd()
9231 
    oprot.writeFieldStop()
9232 
    oprot.writeStructEnd()
9233 
 
3431 rajveer 9234 
  def validate(self):
9235 
    return
9236 
 
9237 
 
94 ashish 9238 
  def __repr__(self):
9239 
    L = ['%s=%r' % (key, value)
9240 
      for key, value in self.__dict__.iteritems()]
9241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9242 
 
9243 
  def __eq__(self, other):
9244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9245 
 
9246 
  def __ne__(self, other):
9247 
    return not (self == other)
9248 
 
3064 chandransh 9249 
class getValidOrdersAmountRange_args:
9250 
 
9251 
  thrift_spec = (
9252 
  )
9253 
 
9254 
  def read(self, iprot):
9255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9257 
      return
9258 
    iprot.readStructBegin()
9259 
    while True:
9260 
      (fname, ftype, fid) = iprot.readFieldBegin()
9261 
      if ftype == TType.STOP:
9262 
        break
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
9272 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9273 
    oprot.writeFieldStop()
9274 
    oprot.writeStructEnd()
9275 
 
3431 rajveer 9276 
  def validate(self):
9277 
    return
9278 
 
9279 
 
3064 chandransh 9280 
  def __repr__(self):
9281 
    L = ['%s=%r' % (key, value)
9282 
      for key, value in self.__dict__.iteritems()]
9283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9284 
 
9285 
  def __eq__(self, other):
9286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9287 
 
9288 
  def __ne__(self, other):
9289 
    return not (self == other)
9290 
 
9291 
class getValidOrdersAmountRange_result:
94 ashish 9292 
  """
9293 
  Attributes:
9294 
   - success
9295 
  """
9296 
 
9297 
  thrift_spec = (
3064 chandransh 9298 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9299 
  )
9300 
 
3064 chandransh 9301 
  def __init__(self, success=None,):
94 ashish 9302 
    self.success = success
9303 
 
9304 
  def read(self, iprot):
9305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9307 
      return
9308 
    iprot.readStructBegin()
9309 
    while True:
9310 
      (fname, ftype, fid) = iprot.readFieldBegin()
9311 
      if ftype == TType.STOP:
9312 
        break
9313 
      if fid == 0:
483 rajveer 9314 
        if ftype == TType.LIST:
9315 
          self.success = []
4133 chandransh 9316 
          (_etype122, _size119) = iprot.readListBegin()
9317 
          for _i123 in xrange(_size119):
9318 
            _elem124 = iprot.readDouble();
9319 
            self.success.append(_elem124)
483 rajveer 9320 
          iprot.readListEnd()
94 ashish 9321 
        else:
9322 
          iprot.skip(ftype)
9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
3064 chandransh 9332 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9333 
    if self.success is not None:
483 rajveer 9334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9335 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9336 
      for iter125 in self.success:
9337 
        oprot.writeDouble(iter125)
483 rajveer 9338 
      oprot.writeListEnd()
94 ashish 9339 
      oprot.writeFieldEnd()
9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
94 ashish 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
3064 chandransh 9358 
class getValidOrders_args:
1528 ankur.sing 9359 
  """
9360 
  Attributes:
3064 chandransh 9361 
   - limit
1528 ankur.sing 9362 
  """
9363 
 
9364 
  thrift_spec = (
9365 
    None, # 0
3064 chandransh 9366 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9367 
  )
9368 
 
3064 chandransh 9369 
  def __init__(self, limit=None,):
9370 
    self.limit = limit
1528 ankur.sing 9371 
 
9372 
  def read(self, iprot):
9373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9375 
      return
9376 
    iprot.readStructBegin()
9377 
    while True:
9378 
      (fname, ftype, fid) = iprot.readFieldBegin()
9379 
      if ftype == TType.STOP:
9380 
        break
9381 
      if fid == 1:
9382 
        if ftype == TType.I64:
3064 chandransh 9383 
          self.limit = iprot.readI64();
1528 ankur.sing 9384 
        else:
9385 
          iprot.skip(ftype)
9386 
      else:
9387 
        iprot.skip(ftype)
9388 
      iprot.readFieldEnd()
9389 
    iprot.readStructEnd()
9390 
 
9391 
  def write(self, oprot):
9392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9394 
      return
3064 chandransh 9395 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9396 
    if self.limit is not None:
3064 chandransh 9397 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9398 
      oprot.writeI64(self.limit)
1528 ankur.sing 9399 
      oprot.writeFieldEnd()
9400 
    oprot.writeFieldStop()
9401 
    oprot.writeStructEnd()
9402 
 
3431 rajveer 9403 
  def validate(self):
9404 
    return
9405 
 
9406 
 
1528 ankur.sing 9407 
  def __repr__(self):
9408 
    L = ['%s=%r' % (key, value)
9409 
      for key, value in self.__dict__.iteritems()]
9410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9411 
 
9412 
  def __eq__(self, other):
9413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9414 
 
9415 
  def __ne__(self, other):
9416 
    return not (self == other)
9417 
 
3064 chandransh 9418 
class getValidOrders_result:
1528 ankur.sing 9419 
  """
9420 
  Attributes:
9421 
   - success
9422 
  """
9423 
 
9424 
  thrift_spec = (
3064 chandransh 9425 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9426 
  )
9427 
 
3064 chandransh 9428 
  def __init__(self, success=None,):
1528 ankur.sing 9429 
    self.success = success
9430 
 
9431 
  def read(self, iprot):
9432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9434 
      return
9435 
    iprot.readStructBegin()
9436 
    while True:
9437 
      (fname, ftype, fid) = iprot.readFieldBegin()
9438 
      if ftype == TType.STOP:
9439 
        break
9440 
      if fid == 0:
3064 chandransh 9441 
        if ftype == TType.LIST:
9442 
          self.success = []
4133 chandransh 9443 
          (_etype129, _size126) = iprot.readListBegin()
9444 
          for _i130 in xrange(_size126):
9445 
            _elem131 = Order()
9446 
            _elem131.read(iprot)
9447 
            self.success.append(_elem131)
3064 chandransh 9448 
          iprot.readListEnd()
1528 ankur.sing 9449 
        else:
9450 
          iprot.skip(ftype)
9451 
      else:
9452 
        iprot.skip(ftype)
9453 
      iprot.readFieldEnd()
9454 
    iprot.readStructEnd()
9455 
 
9456 
  def write(self, oprot):
9457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9459 
      return
3064 chandransh 9460 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9461 
    if self.success is not None:
3064 chandransh 9462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9464 
      for iter132 in self.success:
9465 
        iter132.write(oprot)
3064 chandransh 9466 
      oprot.writeListEnd()
1528 ankur.sing 9467 
      oprot.writeFieldEnd()
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
3431 rajveer 9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
1528 ankur.sing 9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
1220 chandransh 9486 
class batchOrders_args:
9487 
  """
9488 
  Attributes:
9489 
   - warehouseId
9490 
  """
9491 
 
9492 
  thrift_spec = (
9493 
    None, # 0
9494 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9495 
  )
9496 
 
9497 
  def __init__(self, warehouseId=None,):
9498 
    self.warehouseId = warehouseId
9499 
 
9500 
  def read(self, iprot):
9501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9503 
      return
9504 
    iprot.readStructBegin()
9505 
    while True:
9506 
      (fname, ftype, fid) = iprot.readFieldBegin()
9507 
      if ftype == TType.STOP:
9508 
        break
9509 
      if fid == 1:
9510 
        if ftype == TType.I64:
9511 
          self.warehouseId = iprot.readI64();
9512 
        else:
9513 
          iprot.skip(ftype)
9514 
      else:
9515 
        iprot.skip(ftype)
9516 
      iprot.readFieldEnd()
9517 
    iprot.readStructEnd()
9518 
 
9519 
  def write(self, oprot):
9520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9522 
      return
9523 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9524 
    if self.warehouseId is not None:
1220 chandransh 9525 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9526 
      oprot.writeI64(self.warehouseId)
9527 
      oprot.writeFieldEnd()
9528 
    oprot.writeFieldStop()
9529 
    oprot.writeStructEnd()
9530 
 
3431 rajveer 9531 
  def validate(self):
9532 
    return
9533 
 
9534 
 
1220 chandransh 9535 
  def __repr__(self):
9536 
    L = ['%s=%r' % (key, value)
9537 
      for key, value in self.__dict__.iteritems()]
9538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9539 
 
9540 
  def __eq__(self, other):
9541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9542 
 
9543 
  def __ne__(self, other):
9544 
    return not (self == other)
9545 
 
9546 
class batchOrders_result:
9547 
  """
9548 
  Attributes:
9549 
   - success
9550 
   - ex
9551 
  """
9552 
 
9553 
  thrift_spec = (
9554 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9555 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9556 
  )
9557 
 
9558 
  def __init__(self, success=None, ex=None,):
9559 
    self.success = success
9560 
    self.ex = ex
9561 
 
9562 
  def read(self, iprot):
9563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9565 
      return
9566 
    iprot.readStructBegin()
9567 
    while True:
9568 
      (fname, ftype, fid) = iprot.readFieldBegin()
9569 
      if ftype == TType.STOP:
9570 
        break
9571 
      if fid == 0:
9572 
        if ftype == TType.LIST:
9573 
          self.success = []
4133 chandransh 9574 
          (_etype136, _size133) = iprot.readListBegin()
9575 
          for _i137 in xrange(_size133):
9576 
            _elem138 = Order()
9577 
            _elem138.read(iprot)
9578 
            self.success.append(_elem138)
1220 chandransh 9579 
          iprot.readListEnd()
9580 
        else:
9581 
          iprot.skip(ftype)
9582 
      elif fid == 1:
9583 
        if ftype == TType.STRUCT:
9584 
          self.ex = TransactionServiceException()
9585 
          self.ex.read(iprot)
9586 
        else:
9587 
          iprot.skip(ftype)
9588 
      else:
9589 
        iprot.skip(ftype)
9590 
      iprot.readFieldEnd()
9591 
    iprot.readStructEnd()
9592 
 
9593 
  def write(self, oprot):
9594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9596 
      return
9597 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9598 
    if self.success is not None:
1220 chandransh 9599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9600 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9601 
      for iter139 in self.success:
9602 
        iter139.write(oprot)
1220 chandransh 9603 
      oprot.writeListEnd()
9604 
      oprot.writeFieldEnd()
3431 rajveer 9605 
    if self.ex is not None:
1220 chandransh 9606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9607 
      self.ex.write(oprot)
9608 
      oprot.writeFieldEnd()
9609 
    oprot.writeFieldStop()
9610 
    oprot.writeStructEnd()
9611 
 
3431 rajveer 9612 
  def validate(self):
9613 
    return
9614 
 
9615 
 
1220 chandransh 9616 
  def __repr__(self):
9617 
    L = ['%s=%r' % (key, value)
9618 
      for key, value in self.__dict__.iteritems()]
9619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9620 
 
9621 
  def __eq__(self, other):
9622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9623 
 
9624 
  def __ne__(self, other):
9625 
    return not (self == other)
9626 
 
1208 chandransh 9627 
class markOrderAsOutOfStock_args:
9628 
  """
9629 
  Attributes:
9630 
   - orderId
9631 
  """
9632 
 
9633 
  thrift_spec = (
9634 
    None, # 0
9635 
    (1, TType.I64, 'orderId', None, None, ), # 1
9636 
  )
9637 
 
9638 
  def __init__(self, orderId=None,):
9639 
    self.orderId = orderId
9640 
 
9641 
  def read(self, iprot):
9642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9644 
      return
9645 
    iprot.readStructBegin()
9646 
    while True:
9647 
      (fname, ftype, fid) = iprot.readFieldBegin()
9648 
      if ftype == TType.STOP:
9649 
        break
9650 
      if fid == 1:
9651 
        if ftype == TType.I64:
9652 
          self.orderId = iprot.readI64();
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
9664 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9665 
    if self.orderId is not None:
1208 chandransh 9666 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9667 
      oprot.writeI64(self.orderId)
9668 
      oprot.writeFieldEnd()
9669 
    oprot.writeFieldStop()
9670 
    oprot.writeStructEnd()
9671 
 
3431 rajveer 9672 
  def validate(self):
9673 
    return
9674 
 
9675 
 
1208 chandransh 9676 
  def __repr__(self):
9677 
    L = ['%s=%r' % (key, value)
9678 
      for key, value in self.__dict__.iteritems()]
9679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9680 
 
9681 
  def __eq__(self, other):
9682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9683 
 
9684 
  def __ne__(self, other):
9685 
    return not (self == other)
9686 
 
9687 
class markOrderAsOutOfStock_result:
9688 
  """
9689 
  Attributes:
9690 
   - success
9691 
   - ex
9692 
  """
9693 
 
9694 
  thrift_spec = (
9695 
    (0, TType.BOOL, 'success', None, None, ), # 0
9696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9697 
  )
9698 
 
9699 
  def __init__(self, success=None, ex=None,):
9700 
    self.success = success
9701 
    self.ex = ex
9702 
 
9703 
  def read(self, iprot):
9704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9706 
      return
9707 
    iprot.readStructBegin()
9708 
    while True:
9709 
      (fname, ftype, fid) = iprot.readFieldBegin()
9710 
      if ftype == TType.STOP:
9711 
        break
9712 
      if fid == 0:
9713 
        if ftype == TType.BOOL:
9714 
          self.success = iprot.readBool();
9715 
        else:
9716 
          iprot.skip(ftype)
9717 
      elif fid == 1:
9718 
        if ftype == TType.STRUCT:
9719 
          self.ex = TransactionServiceException()
9720 
          self.ex.read(iprot)
9721 
        else:
9722 
          iprot.skip(ftype)
9723 
      else:
9724 
        iprot.skip(ftype)
9725 
      iprot.readFieldEnd()
9726 
    iprot.readStructEnd()
9727 
 
9728 
  def write(self, oprot):
9729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9731 
      return
9732 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9733 
    if self.success is not None:
1208 chandransh 9734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9735 
      oprot.writeBool(self.success)
9736 
      oprot.writeFieldEnd()
3431 rajveer 9737 
    if self.ex is not None:
1208 chandransh 9738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9739 
      self.ex.write(oprot)
9740 
      oprot.writeFieldEnd()
9741 
    oprot.writeFieldStop()
9742 
    oprot.writeStructEnd()
9743 
 
3431 rajveer 9744 
  def validate(self):
9745 
    return
9746 
 
9747 
 
1208 chandransh 9748 
  def __repr__(self):
9749 
    L = ['%s=%r' % (key, value)
9750 
      for key, value in self.__dict__.iteritems()]
9751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9752 
 
9753 
  def __eq__(self, other):
9754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9755 
 
9756 
  def __ne__(self, other):
9757 
    return not (self == other)
9758 
 
3064 chandransh 9759 
class verifyOrder_args:
759 chandransh 9760 
  """
9761 
  Attributes:
3064 chandransh 9762 
   - orderId
759 chandransh 9763 
  """
9764 
 
9765 
  thrift_spec = (
9766 
    None, # 0
3064 chandransh 9767 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9768 
  )
9769 
 
3064 chandransh 9770 
  def __init__(self, orderId=None,):
9771 
    self.orderId = orderId
759 chandransh 9772 
 
9773 
  def read(self, iprot):
9774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9776 
      return
9777 
    iprot.readStructBegin()
9778 
    while True:
9779 
      (fname, ftype, fid) = iprot.readFieldBegin()
9780 
      if ftype == TType.STOP:
9781 
        break
9782 
      if fid == 1:
9783 
        if ftype == TType.I64:
3064 chandransh 9784 
          self.orderId = iprot.readI64();
759 chandransh 9785 
        else:
9786 
          iprot.skip(ftype)
9787 
      else:
9788 
        iprot.skip(ftype)
9789 
      iprot.readFieldEnd()
9790 
    iprot.readStructEnd()
9791 
 
9792 
  def write(self, oprot):
9793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9795 
      return
3064 chandransh 9796 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9797 
    if self.orderId is not None:
3064 chandransh 9798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9799 
      oprot.writeI64(self.orderId)
759 chandransh 9800 
      oprot.writeFieldEnd()
9801 
    oprot.writeFieldStop()
9802 
    oprot.writeStructEnd()
9803 
 
3431 rajveer 9804 
  def validate(self):
9805 
    return
9806 
 
9807 
 
759 chandransh 9808 
  def __repr__(self):
9809 
    L = ['%s=%r' % (key, value)
9810 
      for key, value in self.__dict__.iteritems()]
9811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9812 
 
9813 
  def __eq__(self, other):
9814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9815 
 
9816 
  def __ne__(self, other):
9817 
    return not (self == other)
9818 
 
3064 chandransh 9819 
class verifyOrder_result:
759 chandransh 9820 
  """
9821 
  Attributes:
9822 
   - success
9823 
   - ex
9824 
  """
9825 
 
9826 
  thrift_spec = (
9827 
    (0, TType.BOOL, 'success', None, None, ), # 0
9828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9829 
  )
9830 
 
9831 
  def __init__(self, success=None, ex=None,):
9832 
    self.success = success
9833 
    self.ex = ex
9834 
 
9835 
  def read(self, iprot):
9836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9838 
      return
9839 
    iprot.readStructBegin()
9840 
    while True:
9841 
      (fname, ftype, fid) = iprot.readFieldBegin()
9842 
      if ftype == TType.STOP:
9843 
        break
9844 
      if fid == 0:
9845 
        if ftype == TType.BOOL:
9846 
          self.success = iprot.readBool();
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      elif fid == 1:
9850 
        if ftype == TType.STRUCT:
9851 
          self.ex = TransactionServiceException()
9852 
          self.ex.read(iprot)
9853 
        else:
9854 
          iprot.skip(ftype)
9855 
      else:
9856 
        iprot.skip(ftype)
9857 
      iprot.readFieldEnd()
9858 
    iprot.readStructEnd()
9859 
 
9860 
  def write(self, oprot):
9861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9863 
      return
3064 chandransh 9864 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9865 
    if self.success is not None:
759 chandransh 9866 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9867 
      oprot.writeBool(self.success)
9868 
      oprot.writeFieldEnd()
3431 rajveer 9869 
    if self.ex is not None:
759 chandransh 9870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9871 
      self.ex.write(oprot)
9872 
      oprot.writeFieldEnd()
9873 
    oprot.writeFieldStop()
9874 
    oprot.writeStructEnd()
9875 
 
3431 rajveer 9876 
  def validate(self):
9877 
    return
9878 
 
9879 
 
759 chandransh 9880 
  def __repr__(self):
9881 
    L = ['%s=%r' % (key, value)
9882 
      for key, value in self.__dict__.iteritems()]
9883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9884 
 
9885 
  def __eq__(self, other):
9886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9887 
 
9888 
  def __ne__(self, other):
9889 
    return not (self == other)
9890 
 
3064 chandransh 9891 
class acceptOrder_args:
1113 chandransh 9892 
  """
9893 
  Attributes:
3064 chandransh 9894 
   - orderId
1113 chandransh 9895 
  """
9896 
 
9897 
  thrift_spec = (
9898 
    None, # 0
3064 chandransh 9899 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9900 
  )
9901 
 
3064 chandransh 9902 
  def __init__(self, orderId=None,):
9903 
    self.orderId = orderId
1113 chandransh 9904 
 
9905 
  def read(self, iprot):
9906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9908 
      return
9909 
    iprot.readStructBegin()
9910 
    while True:
9911 
      (fname, ftype, fid) = iprot.readFieldBegin()
9912 
      if ftype == TType.STOP:
9913 
        break
9914 
      if fid == 1:
9915 
        if ftype == TType.I64:
3064 chandransh 9916 
          self.orderId = iprot.readI64();
1113 chandransh 9917 
        else:
9918 
          iprot.skip(ftype)
9919 
      else:
9920 
        iprot.skip(ftype)
9921 
      iprot.readFieldEnd()
9922 
    iprot.readStructEnd()
9923 
 
9924 
  def write(self, oprot):
9925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9927 
      return
3064 chandransh 9928 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9929 
    if self.orderId is not None:
3064 chandransh 9930 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9931 
      oprot.writeI64(self.orderId)
1113 chandransh 9932 
      oprot.writeFieldEnd()
9933 
    oprot.writeFieldStop()
9934 
    oprot.writeStructEnd()
9935 
 
3431 rajveer 9936 
  def validate(self):
9937 
    return
9938 
 
9939 
 
1113 chandransh 9940 
  def __repr__(self):
9941 
    L = ['%s=%r' % (key, value)
9942 
      for key, value in self.__dict__.iteritems()]
9943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9944 
 
9945 
  def __eq__(self, other):
9946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9947 
 
9948 
  def __ne__(self, other):
9949 
    return not (self == other)
9950 
 
3064 chandransh 9951 
class acceptOrder_result:
1113 chandransh 9952 
  """
9953 
  Attributes:
9954 
   - success
9955 
   - ex
9956 
  """
9957 
 
9958 
  thrift_spec = (
3064 chandransh 9959 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9961 
  )
9962 
 
9963 
  def __init__(self, success=None, ex=None,):
9964 
    self.success = success
9965 
    self.ex = ex
9966 
 
9967 
  def read(self, iprot):
9968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9970 
      return
9971 
    iprot.readStructBegin()
9972 
    while True:
9973 
      (fname, ftype, fid) = iprot.readFieldBegin()
9974 
      if ftype == TType.STOP:
9975 
        break
9976 
      if fid == 0:
3064 chandransh 9977 
        if ftype == TType.BOOL:
9978 
          self.success = iprot.readBool();
1113 chandransh 9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      elif fid == 1:
9982 
        if ftype == TType.STRUCT:
9983 
          self.ex = TransactionServiceException()
9984 
          self.ex.read(iprot)
9985 
        else:
9986 
          iprot.skip(ftype)
9987 
      else:
9988 
        iprot.skip(ftype)
9989 
      iprot.readFieldEnd()
9990 
    iprot.readStructEnd()
9991 
 
9992 
  def write(self, oprot):
9993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9995 
      return
3064 chandransh 9996 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9997 
    if self.success is not None:
3064 chandransh 9998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9999 
      oprot.writeBool(self.success)
1113 chandransh 10000 
      oprot.writeFieldEnd()
3431 rajveer 10001 
    if self.ex is not None:
1113 chandransh 10002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10003 
      self.ex.write(oprot)
10004 
      oprot.writeFieldEnd()
10005 
    oprot.writeFieldStop()
10006 
    oprot.writeStructEnd()
10007 
 
3431 rajveer 10008 
  def validate(self):
10009 
    return
10010 
 
10011 
 
1113 chandransh 10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
3064 chandransh 10023 
class addBillingDetails_args:
1135 chandransh 10024 
  """
10025 
  Attributes:
3064 chandransh 10026 
   - orderId
10027 
   - invoice_number
4283 anupam.sin 10028 
   - imeiNumber
10029 
   - itemNumber
3064 chandransh 10030 
   - billed_by
4264 rajveer 10031 
   - jacketNumber
4283 anupam.sin 10032 
   - billingType
10033 
   - vendorId
1135 chandransh 10034 
  """
10035 
 
10036 
  thrift_spec = (
10037 
    None, # 0
3064 chandransh 10038 
    (1, TType.I64, 'orderId', None, None, ), # 1
10039 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 10040 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
10041 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10042 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10043 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10044 
    (7, TType.I64, 'billingType', None, None, ), # 7
10045 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10046 
  )
10047 
 
4283 anupam.sin 10048 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10049 
    self.orderId = orderId
10050 
    self.invoice_number = invoice_number
4283 anupam.sin 10051 
    self.imeiNumber = imeiNumber
10052 
    self.itemNumber = itemNumber
3064 chandransh 10053 
    self.billed_by = billed_by
4264 rajveer 10054 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10055 
    self.billingType = billingType
10056 
    self.vendorId = vendorId
1135 chandransh 10057 
 
10058 
  def read(self, iprot):
10059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10061 
      return
10062 
    iprot.readStructBegin()
10063 
    while True:
10064 
      (fname, ftype, fid) = iprot.readFieldBegin()
10065 
      if ftype == TType.STOP:
10066 
        break
10067 
      if fid == 1:
10068 
        if ftype == TType.I64:
3064 chandransh 10069 
          self.orderId = iprot.readI64();
1135 chandransh 10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      elif fid == 2:
3064 chandransh 10073 
        if ftype == TType.STRING:
10074 
          self.invoice_number = iprot.readString();
1135 chandransh 10075 
        else:
10076 
          iprot.skip(ftype)
3064 chandransh 10077 
      elif fid == 3:
4264 rajveer 10078 
        if ftype == TType.I64:
3064 chandransh 10079 
          self.imeiNumber = iprot.readI64();
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      elif fid == 4:
10083 
        if ftype == TType.STRING:
10084 
          self.itemNumber = iprot.readString();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 5:
10088 
        if ftype == TType.STRING:
4283 anupam.sin 10089 
          self.billed_by = iprot.readString();
3064 chandransh 10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      elif fid == 6:
10093 
        if ftype == TType.I64:
4283 anupam.sin 10094 
          self.jacketNumber = iprot.readI64();
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      elif fid == 7:
10098 
        if ftype == TType.I64:
3064 chandransh 10099 
          self.billingType = iprot.readI64();
10100 
        else:
10101 
          iprot.skip(ftype)
4283 anupam.sin 10102 
      elif fid == 8:
10103 
        if ftype == TType.I64:
10104 
          self.vendorId = iprot.readI64();
10105 
        else:
10106 
          iprot.skip(ftype)
1246 chandransh 10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
4283 anupam.sin 10116 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10117 
    if self.orderId is not None:
3064 chandransh 10118 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10119 
      oprot.writeI64(self.orderId)
1246 chandransh 10120 
      oprot.writeFieldEnd()
4283 anupam.sin 10121 
    if self.invoice_number is not None:
10122 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10123 
      oprot.writeString(self.invoice_number)
1246 chandransh 10124 
      oprot.writeFieldEnd()
3431 rajveer 10125 
    if self.imeiNumber is not None:
3064 chandransh 10126 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
10127 
      oprot.writeI64(self.imeiNumber)
10128 
      oprot.writeFieldEnd()
3431 rajveer 10129 
    if self.itemNumber is not None:
3064 chandransh 10130 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10131 
      oprot.writeString(self.itemNumber)
10132 
      oprot.writeFieldEnd()
4283 anupam.sin 10133 
    if self.billed_by is not None:
10134 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10135 
      oprot.writeString(self.billed_by)
3064 chandransh 10136 
      oprot.writeFieldEnd()
4283 anupam.sin 10137 
    if self.jacketNumber is not None:
10138 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10139 
      oprot.writeI64(self.jacketNumber)
10140 
      oprot.writeFieldEnd()
3431 rajveer 10141 
    if self.billingType is not None:
4283 anupam.sin 10142 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10143 
      oprot.writeI64(self.billingType)
10144 
      oprot.writeFieldEnd()
4283 anupam.sin 10145 
    if self.vendorId is not None:
10146 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10147 
      oprot.writeI64(self.vendorId)
10148 
      oprot.writeFieldEnd()
1246 chandransh 10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
3431 rajveer 10152 
  def validate(self):
10153 
    return
10154 
 
10155 
 
1246 chandransh 10156 
  def __repr__(self):
10157 
    L = ['%s=%r' % (key, value)
10158 
      for key, value in self.__dict__.iteritems()]
10159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10160 
 
10161 
  def __eq__(self, other):
10162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10163 
 
10164 
  def __ne__(self, other):
10165 
    return not (self == other)
10166 
 
4283 anupam.sin 10167 
class addBillingDetails_result:
1246 chandransh 10168 
  """
10169 
  Attributes:
3064 chandransh 10170 
   - success
1246 chandransh 10171 
   - ex
10172 
  """
10173 
 
10174 
  thrift_spec = (
3064 chandransh 10175 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10177 
  )
10178 
 
3064 chandransh 10179 
  def __init__(self, success=None, ex=None,):
10180 
    self.success = success
1246 chandransh 10181 
    self.ex = ex
10182 
 
10183 
  def read(self, iprot):
10184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10186 
      return
10187 
    iprot.readStructBegin()
10188 
    while True:
10189 
      (fname, ftype, fid) = iprot.readFieldBegin()
10190 
      if ftype == TType.STOP:
10191 
        break
3064 chandransh 10192 
      if fid == 0:
10193 
        if ftype == TType.BOOL:
10194 
          self.success = iprot.readBool();
10195 
        else:
10196 
          iprot.skip(ftype)
10197 
      elif fid == 1:
1246 chandransh 10198 
        if ftype == TType.STRUCT:
10199 
          self.ex = TransactionServiceException()
10200 
          self.ex.read(iprot)
10201 
        else:
10202 
          iprot.skip(ftype)
10203 
      else:
10204 
        iprot.skip(ftype)
10205 
      iprot.readFieldEnd()
10206 
    iprot.readStructEnd()
10207 
 
10208 
  def write(self, oprot):
10209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10211 
      return
4283 anupam.sin 10212 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10213 
    if self.success is not None:
3064 chandransh 10214 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10215 
      oprot.writeBool(self.success)
10216 
      oprot.writeFieldEnd()
3431 rajveer 10217 
    if self.ex is not None:
1246 chandransh 10218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10219 
      self.ex.write(oprot)
10220 
      oprot.writeFieldEnd()
10221 
    oprot.writeFieldStop()
10222 
    oprot.writeStructEnd()
10223 
 
3431 rajveer 10224 
  def validate(self):
10225 
    return
10226 
 
10227 
 
1246 chandransh 10228 
  def __repr__(self):
10229 
    L = ['%s=%r' % (key, value)
10230 
      for key, value in self.__dict__.iteritems()]
10231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10232 
 
10233 
  def __eq__(self, other):
10234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10235 
 
10236 
  def __ne__(self, other):
10237 
    return not (self == other)
10238 
 
4579 rajveer 10239 
class addInvoiceNumber_args:
10240 
  """
10241 
  Attributes:
10242 
   - orderId
10243 
   - invoiceNumber
10244 
  """
10245 
 
10246 
  thrift_spec = (
10247 
    None, # 0
10248 
    (1, TType.I64, 'orderId', None, None, ), # 1
10249 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10250 
  )
10251 
 
10252 
  def __init__(self, orderId=None, invoiceNumber=None,):
10253 
    self.orderId = orderId
10254 
    self.invoiceNumber = invoiceNumber
10255 
 
10256 
  def read(self, iprot):
10257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10259 
      return
10260 
    iprot.readStructBegin()
10261 
    while True:
10262 
      (fname, ftype, fid) = iprot.readFieldBegin()
10263 
      if ftype == TType.STOP:
10264 
        break
10265 
      if fid == 1:
10266 
        if ftype == TType.I64:
10267 
          self.orderId = iprot.readI64();
10268 
        else:
10269 
          iprot.skip(ftype)
10270 
      elif fid == 2:
10271 
        if ftype == TType.STRING:
10272 
          self.invoiceNumber = iprot.readString();
10273 
        else:
10274 
          iprot.skip(ftype)
10275 
      else:
10276 
        iprot.skip(ftype)
10277 
      iprot.readFieldEnd()
10278 
    iprot.readStructEnd()
10279 
 
10280 
  def write(self, oprot):
10281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10283 
      return
10284 
    oprot.writeStructBegin('addInvoiceNumber_args')
10285 
    if self.orderId is not None:
10286 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10287 
      oprot.writeI64(self.orderId)
10288 
      oprot.writeFieldEnd()
10289 
    if self.invoiceNumber is not None:
10290 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10291 
      oprot.writeString(self.invoiceNumber)
10292 
      oprot.writeFieldEnd()
10293 
    oprot.writeFieldStop()
10294 
    oprot.writeStructEnd()
10295 
 
10296 
  def validate(self):
10297 
    return
10298 
 
10299 
 
10300 
  def __repr__(self):
10301 
    L = ['%s=%r' % (key, value)
10302 
      for key, value in self.__dict__.iteritems()]
10303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10304 
 
10305 
  def __eq__(self, other):
10306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10307 
 
10308 
  def __ne__(self, other):
10309 
    return not (self == other)
10310 
 
10311 
class addInvoiceNumber_result:
10312 
  """
10313 
  Attributes:
10314 
   - ex
10315 
  """
10316 
 
10317 
  thrift_spec = (
10318 
    None, # 0
10319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10320 
  )
10321 
 
10322 
  def __init__(self, ex=None,):
10323 
    self.ex = ex
10324 
 
10325 
  def read(self, iprot):
10326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10328 
      return
10329 
    iprot.readStructBegin()
10330 
    while True:
10331 
      (fname, ftype, fid) = iprot.readFieldBegin()
10332 
      if ftype == TType.STOP:
10333 
        break
10334 
      if fid == 1:
10335 
        if ftype == TType.STRUCT:
10336 
          self.ex = TransactionServiceException()
10337 
          self.ex.read(iprot)
10338 
        else:
10339 
          iprot.skip(ftype)
10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
10349 
    oprot.writeStructBegin('addInvoiceNumber_result')
10350 
    if self.ex is not None:
10351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10352 
      self.ex.write(oprot)
10353 
      oprot.writeFieldEnd()
10354 
    oprot.writeFieldStop()
10355 
    oprot.writeStructEnd()
10356 
 
10357 
  def validate(self):
10358 
    return
10359 
 
10360 
 
10361 
  def __repr__(self):
10362 
    L = ['%s=%r' % (key, value)
10363 
      for key, value in self.__dict__.iteritems()]
10364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10365 
 
10366 
  def __eq__(self, other):
10367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10368 
 
10369 
  def __ne__(self, other):
10370 
    return not (self == other)
10371 
 
3064 chandransh 10372 
class markOrdersAsManifested_args:
1408 ankur.sing 10373 
  """
10374 
  Attributes:
3064 chandransh 10375 
   - warehouseId
1408 ankur.sing 10376 
   - providerId
3064 chandransh 10377 
   - cod
1408 ankur.sing 10378 
  """
10379 
 
10380 
  thrift_spec = (
10381 
    None, # 0
3064 chandransh 10382 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10383 
    (2, TType.I64, 'providerId', None, None, ), # 2
10384 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10385 
  )
10386 
 
3064 chandransh 10387 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10388 
    self.warehouseId = warehouseId
1408 ankur.sing 10389 
    self.providerId = providerId
3064 chandransh 10390 
    self.cod = cod
1408 ankur.sing 10391 
 
10392 
  def read(self, iprot):
10393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10395 
      return
10396 
    iprot.readStructBegin()
10397 
    while True:
10398 
      (fname, ftype, fid) = iprot.readFieldBegin()
10399 
      if ftype == TType.STOP:
10400 
        break
10401 
      if fid == 1:
10402 
        if ftype == TType.I64:
3064 chandransh 10403 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      elif fid == 2:
10407 
        if ftype == TType.I64:
3064 chandransh 10408 
          self.providerId = iprot.readI64();
1408 ankur.sing 10409 
        else:
10410 
          iprot.skip(ftype)
3064 chandransh 10411 
      elif fid == 3:
10412 
        if ftype == TType.BOOL:
10413 
          self.cod = iprot.readBool();
10414 
        else:
10415 
          iprot.skip(ftype)
1408 ankur.sing 10416 
      else:
10417 
        iprot.skip(ftype)
10418 
      iprot.readFieldEnd()
10419 
    iprot.readStructEnd()
10420 
 
10421 
  def write(self, oprot):
10422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10424 
      return
3064 chandransh 10425 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10426 
    if self.warehouseId is not None:
3064 chandransh 10427 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10428 
      oprot.writeI64(self.warehouseId)
10429 
      oprot.writeFieldEnd()
3431 rajveer 10430 
    if self.providerId is not None:
3064 chandransh 10431 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10432 
      oprot.writeI64(self.providerId)
10433 
      oprot.writeFieldEnd()
3431 rajveer 10434 
    if self.cod is not None:
3064 chandransh 10435 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10436 
      oprot.writeBool(self.cod)
1408 ankur.sing 10437 
      oprot.writeFieldEnd()
10438 
    oprot.writeFieldStop()
10439 
    oprot.writeStructEnd()
10440 
 
3431 rajveer 10441 
  def validate(self):
10442 
    return
10443 
 
10444 
 
1408 ankur.sing 10445 
  def __repr__(self):
10446 
    L = ['%s=%r' % (key, value)
10447 
      for key, value in self.__dict__.iteritems()]
10448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10449 
 
10450 
  def __eq__(self, other):
10451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10452 
 
10453 
  def __ne__(self, other):
10454 
    return not (self == other)
10455 
 
3064 chandransh 10456 
class markOrdersAsManifested_result:
1408 ankur.sing 10457 
  """
10458 
  Attributes:
10459 
   - success
3064 chandransh 10460 
   - ex
1408 ankur.sing 10461 
  """
10462 
 
10463 
  thrift_spec = (
3064 chandransh 10464 
    (0, TType.BOOL, 'success', None, None, ), # 0
10465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10466 
  )
10467 
 
3064 chandransh 10468 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10469 
    self.success = success
3064 chandransh 10470 
    self.ex = ex
1408 ankur.sing 10471 
 
10472 
  def read(self, iprot):
10473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10475 
      return
10476 
    iprot.readStructBegin()
10477 
    while True:
10478 
      (fname, ftype, fid) = iprot.readFieldBegin()
10479 
      if ftype == TType.STOP:
10480 
        break
10481 
      if fid == 0:
3064 chandransh 10482 
        if ftype == TType.BOOL:
10483 
          self.success = iprot.readBool();
1408 ankur.sing 10484 
        else:
10485 
          iprot.skip(ftype)
3064 chandransh 10486 
      elif fid == 1:
10487 
        if ftype == TType.STRUCT:
10488 
          self.ex = TransactionServiceException()
10489 
          self.ex.read(iprot)
10490 
        else:
10491 
          iprot.skip(ftype)
1408 ankur.sing 10492 
      else:
10493 
        iprot.skip(ftype)
10494 
      iprot.readFieldEnd()
10495 
    iprot.readStructEnd()
10496 
 
10497 
  def write(self, oprot):
10498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10500 
      return
3064 chandransh 10501 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10502 
    if self.success is not None:
3064 chandransh 10503 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10504 
      oprot.writeBool(self.success)
1408 ankur.sing 10505 
      oprot.writeFieldEnd()
3431 rajveer 10506 
    if self.ex is not None:
3064 chandransh 10507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10508 
      self.ex.write(oprot)
10509 
      oprot.writeFieldEnd()
1408 ankur.sing 10510 
    oprot.writeFieldStop()
10511 
    oprot.writeStructEnd()
10512 
 
3431 rajveer 10513 
  def validate(self):
10514 
    return
10515 
 
10516 
 
1408 ankur.sing 10517 
  def __repr__(self):
10518 
    L = ['%s=%r' % (key, value)
10519 
      for key, value in self.__dict__.iteritems()]
10520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10521 
 
10522 
  def __eq__(self, other):
10523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10524 
 
10525 
  def __ne__(self, other):
10526 
    return not (self == other)
10527 
 
4410 rajveer 10528 
class markOrdersAsShippedFromWarehouse_args:
10529 
  """
10530 
  Attributes:
10531 
   - warehouseId
10532 
   - providerId
10533 
   - cod
10534 
  """
10535 
 
10536 
  thrift_spec = (
10537 
    None, # 0
10538 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10539 
    (2, TType.I64, 'providerId', None, None, ), # 2
10540 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10541 
  )
10542 
 
10543 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10544 
    self.warehouseId = warehouseId
10545 
    self.providerId = providerId
10546 
    self.cod = cod
10547 
 
10548 
  def read(self, iprot):
10549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10551 
      return
10552 
    iprot.readStructBegin()
10553 
    while True:
10554 
      (fname, ftype, fid) = iprot.readFieldBegin()
10555 
      if ftype == TType.STOP:
10556 
        break
10557 
      if fid == 1:
10558 
        if ftype == TType.I64:
10559 
          self.warehouseId = iprot.readI64();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      elif fid == 2:
10563 
        if ftype == TType.I64:
10564 
          self.providerId = iprot.readI64();
10565 
        else:
10566 
          iprot.skip(ftype)
10567 
      elif fid == 3:
10568 
        if ftype == TType.BOOL:
10569 
          self.cod = iprot.readBool();
10570 
        else:
10571 
          iprot.skip(ftype)
10572 
      else:
10573 
        iprot.skip(ftype)
10574 
      iprot.readFieldEnd()
10575 
    iprot.readStructEnd()
10576 
 
10577 
  def write(self, oprot):
10578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10580 
      return
10581 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10582 
    if self.warehouseId is not None:
10583 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10584 
      oprot.writeI64(self.warehouseId)
10585 
      oprot.writeFieldEnd()
10586 
    if self.providerId is not None:
10587 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10588 
      oprot.writeI64(self.providerId)
10589 
      oprot.writeFieldEnd()
10590 
    if self.cod is not None:
10591 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10592 
      oprot.writeBool(self.cod)
10593 
      oprot.writeFieldEnd()
10594 
    oprot.writeFieldStop()
10595 
    oprot.writeStructEnd()
10596 
 
10597 
  def validate(self):
10598 
    return
10599 
 
10600 
 
10601 
  def __repr__(self):
10602 
    L = ['%s=%r' % (key, value)
10603 
      for key, value in self.__dict__.iteritems()]
10604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10605 
 
10606 
  def __eq__(self, other):
10607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10608 
 
10609 
  def __ne__(self, other):
10610 
    return not (self == other)
10611 
 
10612 
class markOrdersAsShippedFromWarehouse_result:
10613 
  """
10614 
  Attributes:
10615 
   - success
10616 
   - ex
10617 
  """
10618 
 
10619 
  thrift_spec = (
10620 
    (0, TType.BOOL, 'success', None, None, ), # 0
10621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10622 
  )
10623 
 
10624 
  def __init__(self, success=None, ex=None,):
10625 
    self.success = success
10626 
    self.ex = ex
10627 
 
10628 
  def read(self, iprot):
10629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10631 
      return
10632 
    iprot.readStructBegin()
10633 
    while True:
10634 
      (fname, ftype, fid) = iprot.readFieldBegin()
10635 
      if ftype == TType.STOP:
10636 
        break
10637 
      if fid == 0:
10638 
        if ftype == TType.BOOL:
10639 
          self.success = iprot.readBool();
10640 
        else:
10641 
          iprot.skip(ftype)
10642 
      elif fid == 1:
10643 
        if ftype == TType.STRUCT:
10644 
          self.ex = TransactionServiceException()
10645 
          self.ex.read(iprot)
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10658 
    if self.success is not None:
10659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10660 
      oprot.writeBool(self.success)
10661 
      oprot.writeFieldEnd()
10662 
    if self.ex is not None:
10663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10664 
      self.ex.write(oprot)
10665 
      oprot.writeFieldEnd()
10666 
    oprot.writeFieldStop()
10667 
    oprot.writeStructEnd()
10668 
 
10669 
  def validate(self):
10670 
    return
10671 
 
10672 
 
10673 
  def __repr__(self):
10674 
    L = ['%s=%r' % (key, value)
10675 
      for key, value in self.__dict__.iteritems()]
10676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10677 
 
10678 
  def __eq__(self, other):
10679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10680 
 
10681 
  def __ne__(self, other):
10682 
    return not (self == other)
10683 
 
3064 chandransh 10684 
class markOrdersAsPickedUp_args:
304 ashish 10685 
  """
10686 
  Attributes:
3064 chandransh 10687 
   - providerId
10688 
   - pickupDetails
304 ashish 10689 
  """
94 ashish 10690 
 
304 ashish 10691 
  thrift_spec = (
10692 
    None, # 0
3064 chandransh 10693 
    (1, TType.I64, 'providerId', None, None, ), # 1
10694 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10695 
  )
10696 
 
3064 chandransh 10697 
  def __init__(self, providerId=None, pickupDetails=None,):
10698 
    self.providerId = providerId
10699 
    self.pickupDetails = pickupDetails
304 ashish 10700 
 
10701 
  def read(self, iprot):
10702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10704 
      return
10705 
    iprot.readStructBegin()
10706 
    while True:
10707 
      (fname, ftype, fid) = iprot.readFieldBegin()
10708 
      if ftype == TType.STOP:
10709 
        break
10710 
      if fid == 1:
10711 
        if ftype == TType.I64:
3064 chandransh 10712 
          self.providerId = iprot.readI64();
304 ashish 10713 
        else:
10714 
          iprot.skip(ftype)
10715 
      elif fid == 2:
3064 chandransh 10716 
        if ftype == TType.MAP:
10717 
          self.pickupDetails = {}
4133 chandransh 10718 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10719 
          for _i144 in xrange(_size140):
10720 
            _key145 = iprot.readString();
10721 
            _val146 = iprot.readString();
10722 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10723 
          iprot.readMapEnd()
304 ashish 10724 
        else:
10725 
          iprot.skip(ftype)
10726 
      else:
10727 
        iprot.skip(ftype)
10728 
      iprot.readFieldEnd()
10729 
    iprot.readStructEnd()
10730 
 
10731 
  def write(self, oprot):
10732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10734 
      return
3064 chandransh 10735 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10736 
    if self.providerId is not None:
3064 chandransh 10737 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10738 
      oprot.writeI64(self.providerId)
304 ashish 10739 
      oprot.writeFieldEnd()
3431 rajveer 10740 
    if self.pickupDetails is not None:
3064 chandransh 10741 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10742 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10743 
      for kiter147,viter148 in self.pickupDetails.items():
10744 
        oprot.writeString(kiter147)
10745 
        oprot.writeString(viter148)
3064 chandransh 10746 
      oprot.writeMapEnd()
304 ashish 10747 
      oprot.writeFieldEnd()
10748 
    oprot.writeFieldStop()
10749 
    oprot.writeStructEnd()
10750 
 
3431 rajveer 10751 
  def validate(self):
10752 
    return
10753 
 
10754 
 
304 ashish 10755 
  def __repr__(self):
10756 
    L = ['%s=%r' % (key, value)
10757 
      for key, value in self.__dict__.iteritems()]
10758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10759 
 
10760 
  def __eq__(self, other):
10761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10762 
 
10763 
  def __ne__(self, other):
10764 
    return not (self == other)
10765 
 
3064 chandransh 10766 
class markOrdersAsPickedUp_result:
304 ashish 10767 
  """
10768 
  Attributes:
10769 
   - success
3064 chandransh 10770 
   - ex
304 ashish 10771 
  """
10772 
 
10773 
  thrift_spec = (
3064 chandransh 10774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10776 
  )
10777 
 
3064 chandransh 10778 
  def __init__(self, success=None, ex=None,):
304 ashish 10779 
    self.success = success
3064 chandransh 10780 
    self.ex = ex
304 ashish 10781 
 
10782 
  def read(self, iprot):
10783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10785 
      return
10786 
    iprot.readStructBegin()
10787 
    while True:
10788 
      (fname, ftype, fid) = iprot.readFieldBegin()
10789 
      if ftype == TType.STOP:
10790 
        break
10791 
      if fid == 0:
10792 
        if ftype == TType.LIST:
10793 
          self.success = []
4133 chandransh 10794 
          (_etype152, _size149) = iprot.readListBegin()
10795 
          for _i153 in xrange(_size149):
10796 
            _elem154 = Order()
10797 
            _elem154.read(iprot)
10798 
            self.success.append(_elem154)
304 ashish 10799 
          iprot.readListEnd()
10800 
        else:
10801 
          iprot.skip(ftype)
3064 chandransh 10802 
      elif fid == 1:
10803 
        if ftype == TType.STRUCT:
10804 
          self.ex = TransactionServiceException()
10805 
          self.ex.read(iprot)
10806 
        else:
10807 
          iprot.skip(ftype)
304 ashish 10808 
      else:
10809 
        iprot.skip(ftype)
10810 
      iprot.readFieldEnd()
10811 
    iprot.readStructEnd()
10812 
 
10813 
  def write(self, oprot):
10814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10816 
      return
3064 chandransh 10817 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10818 
    if self.success is not None:
304 ashish 10819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10821 
      for iter155 in self.success:
10822 
        iter155.write(oprot)
304 ashish 10823 
      oprot.writeListEnd()
10824 
      oprot.writeFieldEnd()
3431 rajveer 10825 
    if self.ex is not None:
3064 chandransh 10826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10827 
      self.ex.write(oprot)
10828 
      oprot.writeFieldEnd()
304 ashish 10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
3431 rajveer 10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
304 ashish 10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
3064 chandransh 10847 
class markOrdersAsDelivered_args:
304 ashish 10848 
  """
10849 
  Attributes:
3064 chandransh 10850 
   - providerId
10851 
   - deliveredOrders
304 ashish 10852 
  """
10853 
 
10854 
  thrift_spec = (
10855 
    None, # 0
3064 chandransh 10856 
    (1, TType.I64, 'providerId', None, None, ), # 1
10857 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10858 
  )
10859 
 
3064 chandransh 10860 
  def __init__(self, providerId=None, deliveredOrders=None,):
10861 
    self.providerId = providerId
10862 
    self.deliveredOrders = deliveredOrders
304 ashish 10863 
 
10864 
  def read(self, iprot):
10865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10867 
      return
10868 
    iprot.readStructBegin()
10869 
    while True:
10870 
      (fname, ftype, fid) = iprot.readFieldBegin()
10871 
      if ftype == TType.STOP:
10872 
        break
10873 
      if fid == 1:
10874 
        if ftype == TType.I64:
3064 chandransh 10875 
          self.providerId = iprot.readI64();
304 ashish 10876 
        else:
10877 
          iprot.skip(ftype)
10878 
      elif fid == 2:
3064 chandransh 10879 
        if ftype == TType.MAP:
10880 
          self.deliveredOrders = {}
4133 chandransh 10881 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10882 
          for _i160 in xrange(_size156):
10883 
            _key161 = iprot.readString();
10884 
            _val162 = iprot.readString();
10885 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10886 
          iprot.readMapEnd()
304 ashish 10887 
        else:
10888 
          iprot.skip(ftype)
10889 
      else:
10890 
        iprot.skip(ftype)
10891 
      iprot.readFieldEnd()
10892 
    iprot.readStructEnd()
10893 
 
10894 
  def write(self, oprot):
10895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10897 
      return
3064 chandransh 10898 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10899 
    if self.providerId is not None:
3064 chandransh 10900 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10901 
      oprot.writeI64(self.providerId)
304 ashish 10902 
      oprot.writeFieldEnd()
3431 rajveer 10903 
    if self.deliveredOrders is not None:
3064 chandransh 10904 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10905 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10906 
      for kiter163,viter164 in self.deliveredOrders.items():
10907 
        oprot.writeString(kiter163)
10908 
        oprot.writeString(viter164)
3064 chandransh 10909 
      oprot.writeMapEnd()
304 ashish 10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
3431 rajveer 10914 
  def validate(self):
10915 
    return
10916 
 
10917 
 
304 ashish 10918 
  def __repr__(self):
10919 
    L = ['%s=%r' % (key, value)
10920 
      for key, value in self.__dict__.iteritems()]
10921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10922 
 
10923 
  def __eq__(self, other):
10924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10925 
 
10926 
  def __ne__(self, other):
10927 
    return not (self == other)
10928 
 
3064 chandransh 10929 
class markOrdersAsDelivered_result:
10930 
  """
10931 
  Attributes:
10932 
   - ex
10933 
  """
304 ashish 10934 
 
10935 
  thrift_spec = (
3064 chandransh 10936 
    None, # 0
10937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10938 
  )
10939 
 
3064 chandransh 10940 
  def __init__(self, ex=None,):
10941 
    self.ex = ex
304 ashish 10942 
 
1596 ankur.sing 10943 
  def read(self, iprot):
10944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10946 
      return
10947 
    iprot.readStructBegin()
10948 
    while True:
10949 
      (fname, ftype, fid) = iprot.readFieldBegin()
10950 
      if ftype == TType.STOP:
10951 
        break
3064 chandransh 10952 
      if fid == 1:
10953 
        if ftype == TType.STRUCT:
10954 
          self.ex = TransactionServiceException()
10955 
          self.ex.read(iprot)
10956 
        else:
10957 
          iprot.skip(ftype)
1596 ankur.sing 10958 
      else:
10959 
        iprot.skip(ftype)
10960 
      iprot.readFieldEnd()
10961 
    iprot.readStructEnd()
10962 
 
10963 
  def write(self, oprot):
10964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10966 
      return
3064 chandransh 10967 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10968 
    if self.ex is not None:
3064 chandransh 10969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10970 
      self.ex.write(oprot)
10971 
      oprot.writeFieldEnd()
1596 ankur.sing 10972 
    oprot.writeFieldStop()
10973 
    oprot.writeStructEnd()
10974 
 
3431 rajveer 10975 
  def validate(self):
10976 
    return
10977 
 
10978 
 
1596 ankur.sing 10979 
  def __repr__(self):
10980 
    L = ['%s=%r' % (key, value)
10981 
      for key, value in self.__dict__.iteritems()]
10982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10983 
 
10984 
  def __eq__(self, other):
10985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10986 
 
10987 
  def __ne__(self, other):
10988 
    return not (self == other)
10989 
 
3064 chandransh 10990 
class markOrdersAsFailed_args:
1596 ankur.sing 10991 
  """
10992 
  Attributes:
3064 chandransh 10993 
   - providerId
10994 
   - returnedOrders
1596 ankur.sing 10995 
  """
10996 
 
10997 
  thrift_spec = (
3064 chandransh 10998 
    None, # 0
10999 
    (1, TType.I64, 'providerId', None, None, ), # 1
11000 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11001 
  )
11002 
 
3064 chandransh 11003 
  def __init__(self, providerId=None, returnedOrders=None,):
11004 
    self.providerId = providerId
11005 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11006 
 
11007 
  def read(self, iprot):
11008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11010 
      return
11011 
    iprot.readStructBegin()
11012 
    while True:
11013 
      (fname, ftype, fid) = iprot.readFieldBegin()
11014 
      if ftype == TType.STOP:
11015 
        break
3064 chandransh 11016 
      if fid == 1:
1596 ankur.sing 11017 
        if ftype == TType.I64:
3064 chandransh 11018 
          self.providerId = iprot.readI64();
1596 ankur.sing 11019 
        else:
11020 
          iprot.skip(ftype)
3064 chandransh 11021 
      elif fid == 2:
11022 
        if ftype == TType.MAP:
11023 
          self.returnedOrders = {}
4133 chandransh 11024 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11025 
          for _i169 in xrange(_size165):
11026 
            _key170 = iprot.readString();
11027 
            _val171 = iprot.readString();
11028 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11029 
          iprot.readMapEnd()
11030 
        else:
11031 
          iprot.skip(ftype)
1596 ankur.sing 11032 
      else:
11033 
        iprot.skip(ftype)
11034 
      iprot.readFieldEnd()
11035 
    iprot.readStructEnd()
11036 
 
11037 
  def write(self, oprot):
11038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11040 
      return
3064 chandransh 11041 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11042 
    if self.providerId is not None:
3064 chandransh 11043 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11044 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11045 
      oprot.writeFieldEnd()
3431 rajveer 11046 
    if self.returnedOrders is not None:
3064 chandransh 11047 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11048 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11049 
      for kiter172,viter173 in self.returnedOrders.items():
11050 
        oprot.writeString(kiter172)
11051 
        oprot.writeString(viter173)
3064 chandransh 11052 
      oprot.writeMapEnd()
11053 
      oprot.writeFieldEnd()
1596 ankur.sing 11054 
    oprot.writeFieldStop()
11055 
    oprot.writeStructEnd()
11056 
 
3431 rajveer 11057 
  def validate(self):
11058 
    return
11059 
 
11060 
 
1596 ankur.sing 11061 
  def __repr__(self):
11062 
    L = ['%s=%r' % (key, value)
11063 
      for key, value in self.__dict__.iteritems()]
11064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11065 
 
11066 
  def __eq__(self, other):
11067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11068 
 
11069 
  def __ne__(self, other):
11070 
    return not (self == other)
11071 
 
3064 chandransh 11072 
class markOrdersAsFailed_result:
11073 
  """
11074 
  Attributes:
11075 
   - ex
11076 
  """
1596 ankur.sing 11077 
 
1627 ankur.sing 11078 
  thrift_spec = (
3064 chandransh 11079 
    None, # 0
11080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11081 
  )
11082 
 
3064 chandransh 11083 
  def __init__(self, ex=None,):
11084 
    self.ex = ex
11085 
 
1627 ankur.sing 11086 
  def read(self, iprot):
11087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11089 
      return
11090 
    iprot.readStructBegin()
11091 
    while True:
11092 
      (fname, ftype, fid) = iprot.readFieldBegin()
11093 
      if ftype == TType.STOP:
11094 
        break
3064 chandransh 11095 
      if fid == 1:
11096 
        if ftype == TType.STRUCT:
11097 
          self.ex = TransactionServiceException()
11098 
          self.ex.read(iprot)
11099 
        else:
11100 
          iprot.skip(ftype)
1627 ankur.sing 11101 
      else:
11102 
        iprot.skip(ftype)
11103 
      iprot.readFieldEnd()
11104 
    iprot.readStructEnd()
11105 
 
11106 
  def write(self, oprot):
11107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11109 
      return
3064 chandransh 11110 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11111 
    if self.ex is not None:
3064 chandransh 11112 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11113 
      self.ex.write(oprot)
11114 
      oprot.writeFieldEnd()
1627 ankur.sing 11115 
    oprot.writeFieldStop()
11116 
    oprot.writeStructEnd()
11117 
 
3431 rajveer 11118 
  def validate(self):
11119 
    return
11120 
 
11121 
 
1627 ankur.sing 11122 
  def __repr__(self):
11123 
    L = ['%s=%r' % (key, value)
11124 
      for key, value in self.__dict__.iteritems()]
11125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11126 
 
11127 
  def __eq__(self, other):
11128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11129 
 
11130 
  def __ne__(self, other):
11131 
    return not (self == other)
11132 
 
3064 chandransh 11133 
class updateNonDeliveryReason_args:
1627 ankur.sing 11134 
  """
11135 
  Attributes:
3064 chandransh 11136 
   - providerId
11137 
   - undeliveredOrders
1627 ankur.sing 11138 
  """
11139 
 
11140 
  thrift_spec = (
3064 chandransh 11141 
    None, # 0
11142 
    (1, TType.I64, 'providerId', None, None, ), # 1
11143 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11144 
  )
11145 
 
3064 chandransh 11146 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11147 
    self.providerId = providerId
11148 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11149 
 
11150 
  def read(self, iprot):
11151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11153 
      return
11154 
    iprot.readStructBegin()
11155 
    while True:
11156 
      (fname, ftype, fid) = iprot.readFieldBegin()
11157 
      if ftype == TType.STOP:
11158 
        break
3064 chandransh 11159 
      if fid == 1:
1627 ankur.sing 11160 
        if ftype == TType.I64:
3064 chandransh 11161 
          self.providerId = iprot.readI64();
1627 ankur.sing 11162 
        else:
11163 
          iprot.skip(ftype)
3064 chandransh 11164 
      elif fid == 2:
11165 
        if ftype == TType.MAP:
11166 
          self.undeliveredOrders = {}
4133 chandransh 11167 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11168 
          for _i178 in xrange(_size174):
11169 
            _key179 = iprot.readString();
11170 
            _val180 = iprot.readString();
11171 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11172 
          iprot.readMapEnd()
11173 
        else:
11174 
          iprot.skip(ftype)
1627 ankur.sing 11175 
      else:
11176 
        iprot.skip(ftype)
11177 
      iprot.readFieldEnd()
11178 
    iprot.readStructEnd()
11179 
 
11180 
  def write(self, oprot):
11181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11183 
      return
3064 chandransh 11184 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11185 
    if self.providerId is not None:
3064 chandransh 11186 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11187 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11188 
      oprot.writeFieldEnd()
3431 rajveer 11189 
    if self.undeliveredOrders is not None:
3064 chandransh 11190 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11191 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11192 
      for kiter181,viter182 in self.undeliveredOrders.items():
11193 
        oprot.writeString(kiter181)
11194 
        oprot.writeString(viter182)
3064 chandransh 11195 
      oprot.writeMapEnd()
11196 
      oprot.writeFieldEnd()
1627 ankur.sing 11197 
    oprot.writeFieldStop()
11198 
    oprot.writeStructEnd()
11199 
 
3431 rajveer 11200 
  def validate(self):
11201 
    return
11202 
 
11203 
 
1627 ankur.sing 11204 
  def __repr__(self):
11205 
    L = ['%s=%r' % (key, value)
11206 
      for key, value in self.__dict__.iteritems()]
11207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11208 
 
11209 
  def __eq__(self, other):
11210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11211 
 
11212 
  def __ne__(self, other):
11213 
    return not (self == other)
11214 
 
3064 chandransh 11215 
class updateNonDeliveryReason_result:
1627 ankur.sing 11216 
  """
11217 
  Attributes:
4581 phani.kuma 11218 
   - success
3064 chandransh 11219 
   - ex
1627 ankur.sing 11220 
  """
11221 
 
11222 
  thrift_spec = (
4581 phani.kuma 11223 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11225 
  )
11226 
 
4581 phani.kuma 11227 
  def __init__(self, success=None, ex=None,):
11228 
    self.success = success
3064 chandransh 11229 
    self.ex = ex
1627 ankur.sing 11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
4581 phani.kuma 11240 
      if fid == 0:
11241 
        if ftype == TType.LIST:
11242 
          self.success = []
11243 
          (_etype186, _size183) = iprot.readListBegin()
11244 
          for _i187 in xrange(_size183):
11245 
            _elem188 = Order()
11246 
            _elem188.read(iprot)
11247 
            self.success.append(_elem188)
11248 
          iprot.readListEnd()
11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      elif fid == 1:
3064 chandransh 11252 
        if ftype == TType.STRUCT:
11253 
          self.ex = TransactionServiceException()
11254 
          self.ex.read(iprot)
1627 ankur.sing 11255 
        else:
11256 
          iprot.skip(ftype)
11257 
      else:
11258 
        iprot.skip(ftype)
11259 
      iprot.readFieldEnd()
11260 
    iprot.readStructEnd()
11261 
 
11262 
  def write(self, oprot):
11263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11265 
      return
3064 chandransh 11266 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11267 
    if self.success is not None:
11268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11269 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11270 
      for iter189 in self.success:
11271 
        iter189.write(oprot)
11272 
      oprot.writeListEnd()
11273 
      oprot.writeFieldEnd()
3431 rajveer 11274 
    if self.ex is not None:
3064 chandransh 11275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11276 
      self.ex.write(oprot)
1627 ankur.sing 11277 
      oprot.writeFieldEnd()
11278 
    oprot.writeFieldStop()
11279 
    oprot.writeStructEnd()
11280 
 
3431 rajveer 11281 
  def validate(self):
11282 
    return
11283 
 
11284 
 
1627 ankur.sing 11285 
  def __repr__(self):
11286 
    L = ['%s=%r' % (key, value)
11287 
      for key, value in self.__dict__.iteritems()]
11288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11289 
 
11290 
  def __eq__(self, other):
11291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11292 
 
11293 
  def __ne__(self, other):
11294 
    return not (self == other)
11295 
 
3064 chandransh 11296 
class getUndeliveredOrders_args:
1886 ankur.sing 11297 
  """
11298 
  Attributes:
3064 chandransh 11299 
   - providerId
11300 
   - warehouseId
1886 ankur.sing 11301 
  """
1627 ankur.sing 11302 
 
1886 ankur.sing 11303 
  thrift_spec = (
11304 
    None, # 0
3064 chandransh 11305 
    (1, TType.I64, 'providerId', None, None, ), # 1
11306 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11307 
  )
11308 
 
3064 chandransh 11309 
  def __init__(self, providerId=None, warehouseId=None,):
11310 
    self.providerId = providerId
11311 
    self.warehouseId = warehouseId
1886 ankur.sing 11312 
 
11313 
  def read(self, iprot):
11314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11316 
      return
11317 
    iprot.readStructBegin()
11318 
    while True:
11319 
      (fname, ftype, fid) = iprot.readFieldBegin()
11320 
      if ftype == TType.STOP:
11321 
        break
11322 
      if fid == 1:
11323 
        if ftype == TType.I64:
3064 chandransh 11324 
          self.providerId = iprot.readI64();
1886 ankur.sing 11325 
        else:
11326 
          iprot.skip(ftype)
3064 chandransh 11327 
      elif fid == 2:
11328 
        if ftype == TType.I64:
11329 
          self.warehouseId = iprot.readI64();
11330 
        else:
11331 
          iprot.skip(ftype)
1886 ankur.sing 11332 
      else:
11333 
        iprot.skip(ftype)
11334 
      iprot.readFieldEnd()
11335 
    iprot.readStructEnd()
11336 
 
11337 
  def write(self, oprot):
11338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11340 
      return
3064 chandransh 11341 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11342 
    if self.providerId is not None:
3064 chandransh 11343 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11344 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11345 
      oprot.writeFieldEnd()
3431 rajveer 11346 
    if self.warehouseId is not None:
3064 chandransh 11347 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11348 
      oprot.writeI64(self.warehouseId)
11349 
      oprot.writeFieldEnd()
1886 ankur.sing 11350 
    oprot.writeFieldStop()
11351 
    oprot.writeStructEnd()
11352 
 
3431 rajveer 11353 
  def validate(self):
11354 
    return
11355 
 
11356 
 
1886 ankur.sing 11357 
  def __repr__(self):
11358 
    L = ['%s=%r' % (key, value)
11359 
      for key, value in self.__dict__.iteritems()]
11360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11361 
 
11362 
  def __eq__(self, other):
11363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11364 
 
11365 
  def __ne__(self, other):
11366 
    return not (self == other)
11367 
 
3064 chandransh 11368 
class getUndeliveredOrders_result:
1886 ankur.sing 11369 
  """
11370 
  Attributes:
11371 
   - success
11372 
  """
11373 
 
11374 
  thrift_spec = (
11375 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11376 
  )
11377 
 
11378 
  def __init__(self, success=None,):
11379 
    self.success = success
11380 
 
11381 
  def read(self, iprot):
11382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11384 
      return
11385 
    iprot.readStructBegin()
11386 
    while True:
11387 
      (fname, ftype, fid) = iprot.readFieldBegin()
11388 
      if ftype == TType.STOP:
11389 
        break
11390 
      if fid == 0:
11391 
        if ftype == TType.LIST:
11392 
          self.success = []
4581 phani.kuma 11393 
          (_etype193, _size190) = iprot.readListBegin()
11394 
          for _i194 in xrange(_size190):
11395 
            _elem195 = Order()
11396 
            _elem195.read(iprot)
11397 
            self.success.append(_elem195)
1886 ankur.sing 11398 
          iprot.readListEnd()
11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
3064 chandransh 11410 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11411 
    if self.success is not None:
1886 ankur.sing 11412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11414 
      for iter196 in self.success:
11415 
        iter196.write(oprot)
1886 ankur.sing 11416 
      oprot.writeListEnd()
11417 
      oprot.writeFieldEnd()
11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
3431 rajveer 11421 
  def validate(self):
11422 
    return
11423 
 
11424 
 
1886 ankur.sing 11425 
  def __repr__(self):
11426 
    L = ['%s=%r' % (key, value)
11427 
      for key, value in self.__dict__.iteritems()]
11428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11429 
 
11430 
  def __eq__(self, other):
11431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11432 
 
11433 
  def __ne__(self, other):
11434 
    return not (self == other)
11435 
 
2536 chandransh 11436 
class toggleDOAFlag_args:
11437 
  """
11438 
  Attributes:
11439 
   - orderId
11440 
  """
1886 ankur.sing 11441 
 
2536 chandransh 11442 
  thrift_spec = (
11443 
    None, # 0
11444 
    (1, TType.I64, 'orderId', None, None, ), # 1
11445 
  )
11446 
 
11447 
  def __init__(self, orderId=None,):
11448 
    self.orderId = orderId
11449 
 
11450 
  def read(self, iprot):
11451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11453 
      return
11454 
    iprot.readStructBegin()
11455 
    while True:
11456 
      (fname, ftype, fid) = iprot.readFieldBegin()
11457 
      if ftype == TType.STOP:
11458 
        break
11459 
      if fid == 1:
11460 
        if ftype == TType.I64:
11461 
          self.orderId = iprot.readI64();
11462 
        else:
11463 
          iprot.skip(ftype)
11464 
      else:
11465 
        iprot.skip(ftype)
11466 
      iprot.readFieldEnd()
11467 
    iprot.readStructEnd()
11468 
 
11469 
  def write(self, oprot):
11470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11472 
      return
11473 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11474 
    if self.orderId is not None:
2536 chandransh 11475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11476 
      oprot.writeI64(self.orderId)
11477 
      oprot.writeFieldEnd()
11478 
    oprot.writeFieldStop()
11479 
    oprot.writeStructEnd()
11480 
 
3431 rajveer 11481 
  def validate(self):
11482 
    return
11483 
 
11484 
 
2536 chandransh 11485 
  def __repr__(self):
11486 
    L = ['%s=%r' % (key, value)
11487 
      for key, value in self.__dict__.iteritems()]
11488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11489 
 
11490 
  def __eq__(self, other):
11491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11492 
 
11493 
  def __ne__(self, other):
11494 
    return not (self == other)
11495 
 
11496 
class toggleDOAFlag_result:
11497 
  """
11498 
  Attributes:
11499 
   - success
11500 
   - ex
11501 
  """
11502 
 
11503 
  thrift_spec = (
11504 
    (0, TType.BOOL, 'success', None, None, ), # 0
11505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11506 
  )
11507 
 
11508 
  def __init__(self, success=None, ex=None,):
11509 
    self.success = success
11510 
    self.ex = ex
11511 
 
11512 
  def read(self, iprot):
11513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11515 
      return
11516 
    iprot.readStructBegin()
11517 
    while True:
11518 
      (fname, ftype, fid) = iprot.readFieldBegin()
11519 
      if ftype == TType.STOP:
11520 
        break
11521 
      if fid == 0:
11522 
        if ftype == TType.BOOL:
11523 
          self.success = iprot.readBool();
11524 
        else:
11525 
          iprot.skip(ftype)
11526 
      elif fid == 1:
11527 
        if ftype == TType.STRUCT:
11528 
          self.ex = TransactionServiceException()
11529 
          self.ex.read(iprot)
11530 
        else:
11531 
          iprot.skip(ftype)
11532 
      else:
11533 
        iprot.skip(ftype)
11534 
      iprot.readFieldEnd()
11535 
    iprot.readStructEnd()
11536 
 
11537 
  def write(self, oprot):
11538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11540 
      return
11541 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11542 
    if self.success is not None:
2536 chandransh 11543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11544 
      oprot.writeBool(self.success)
11545 
      oprot.writeFieldEnd()
3431 rajveer 11546 
    if self.ex is not None:
2536 chandransh 11547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11548 
      self.ex.write(oprot)
11549 
      oprot.writeFieldEnd()
11550 
    oprot.writeFieldStop()
11551 
    oprot.writeStructEnd()
11552 
 
3431 rajveer 11553 
  def validate(self):
11554 
    return
11555 
 
11556 
 
2536 chandransh 11557 
  def __repr__(self):
11558 
    L = ['%s=%r' % (key, value)
11559 
      for key, value in self.__dict__.iteritems()]
11560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11561 
 
11562 
  def __eq__(self, other):
11563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11564 
 
11565 
  def __ne__(self, other):
11566 
    return not (self == other)
11567 
 
4454 rajveer 11568 
class markOrderDoaRequestReceived_args:
11569 
  """
11570 
  Attributes:
11571 
   - orderId
11572 
  """
11573 
 
11574 
  thrift_spec = (
11575 
    None, # 0
11576 
    (1, TType.I64, 'orderId', None, None, ), # 1
11577 
  )
11578 
 
11579 
  def __init__(self, orderId=None,):
11580 
    self.orderId = orderId
11581 
 
11582 
  def read(self, iprot):
11583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11585 
      return
11586 
    iprot.readStructBegin()
11587 
    while True:
11588 
      (fname, ftype, fid) = iprot.readFieldBegin()
11589 
      if ftype == TType.STOP:
11590 
        break
11591 
      if fid == 1:
11592 
        if ftype == TType.I64:
11593 
          self.orderId = iprot.readI64();
11594 
        else:
11595 
          iprot.skip(ftype)
11596 
      else:
11597 
        iprot.skip(ftype)
11598 
      iprot.readFieldEnd()
11599 
    iprot.readStructEnd()
11600 
 
11601 
  def write(self, oprot):
11602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11604 
      return
11605 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11606 
    if self.orderId is not None:
11607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11608 
      oprot.writeI64(self.orderId)
11609 
      oprot.writeFieldEnd()
11610 
    oprot.writeFieldStop()
11611 
    oprot.writeStructEnd()
11612 
 
11613 
  def validate(self):
11614 
    return
11615 
 
11616 
 
11617 
  def __repr__(self):
11618 
    L = ['%s=%r' % (key, value)
11619 
      for key, value in self.__dict__.iteritems()]
11620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11621 
 
11622 
  def __eq__(self, other):
11623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11624 
 
11625 
  def __ne__(self, other):
11626 
    return not (self == other)
11627 
 
11628 
class markOrderDoaRequestReceived_result:
11629 
  """
11630 
  Attributes:
11631 
   - success
11632 
   - ex
11633 
  """
11634 
 
11635 
  thrift_spec = (
11636 
    (0, TType.BOOL, 'success', None, None, ), # 0
11637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11638 
  )
11639 
 
11640 
  def __init__(self, success=None, ex=None,):
11641 
    self.success = success
11642 
    self.ex = ex
11643 
 
11644 
  def read(self, iprot):
11645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11647 
      return
11648 
    iprot.readStructBegin()
11649 
    while True:
11650 
      (fname, ftype, fid) = iprot.readFieldBegin()
11651 
      if ftype == TType.STOP:
11652 
        break
11653 
      if fid == 0:
11654 
        if ftype == TType.BOOL:
11655 
          self.success = iprot.readBool();
11656 
        else:
11657 
          iprot.skip(ftype)
11658 
      elif fid == 1:
11659 
        if ftype == TType.STRUCT:
11660 
          self.ex = TransactionServiceException()
11661 
          self.ex.read(iprot)
11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      else:
11665 
        iprot.skip(ftype)
11666 
      iprot.readFieldEnd()
11667 
    iprot.readStructEnd()
11668 
 
11669 
  def write(self, oprot):
11670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11672 
      return
11673 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11674 
    if self.success is not None:
11675 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11676 
      oprot.writeBool(self.success)
11677 
      oprot.writeFieldEnd()
11678 
    if self.ex is not None:
11679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11680 
      self.ex.write(oprot)
11681 
      oprot.writeFieldEnd()
11682 
    oprot.writeFieldStop()
11683 
    oprot.writeStructEnd()
11684 
 
11685 
  def validate(self):
11686 
    return
11687 
 
11688 
 
11689 
  def __repr__(self):
11690 
    L = ['%s=%r' % (key, value)
11691 
      for key, value in self.__dict__.iteritems()]
11692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11693 
 
11694 
  def __eq__(self, other):
11695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11696 
 
11697 
  def __ne__(self, other):
11698 
    return not (self == other)
11699 
 
11700 
class markOrderDoaRequestAuthorized_args:
11701 
  """
11702 
  Attributes:
11703 
   - orderId
11704 
   - isAuthorized
11705 
  """
11706 
 
11707 
  thrift_spec = (
11708 
    None, # 0
11709 
    (1, TType.I64, 'orderId', None, None, ), # 1
11710 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11711 
  )
11712 
 
11713 
  def __init__(self, orderId=None, isAuthorized=None,):
11714 
    self.orderId = orderId
11715 
    self.isAuthorized = isAuthorized
11716 
 
11717 
  def read(self, iprot):
11718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11720 
      return
11721 
    iprot.readStructBegin()
11722 
    while True:
11723 
      (fname, ftype, fid) = iprot.readFieldBegin()
11724 
      if ftype == TType.STOP:
11725 
        break
11726 
      if fid == 1:
11727 
        if ftype == TType.I64:
11728 
          self.orderId = iprot.readI64();
11729 
        else:
11730 
          iprot.skip(ftype)
11731 
      elif fid == 2:
11732 
        if ftype == TType.BOOL:
11733 
          self.isAuthorized = iprot.readBool();
11734 
        else:
11735 
          iprot.skip(ftype)
11736 
      else:
11737 
        iprot.skip(ftype)
11738 
      iprot.readFieldEnd()
11739 
    iprot.readStructEnd()
11740 
 
11741 
  def write(self, oprot):
11742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11744 
      return
11745 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11746 
    if self.orderId is not None:
11747 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11748 
      oprot.writeI64(self.orderId)
11749 
      oprot.writeFieldEnd()
11750 
    if self.isAuthorized is not None:
11751 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11752 
      oprot.writeBool(self.isAuthorized)
11753 
      oprot.writeFieldEnd()
11754 
    oprot.writeFieldStop()
11755 
    oprot.writeStructEnd()
11756 
 
11757 
  def validate(self):
11758 
    return
11759 
 
11760 
 
11761 
  def __repr__(self):
11762 
    L = ['%s=%r' % (key, value)
11763 
      for key, value in self.__dict__.iteritems()]
11764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11765 
 
11766 
  def __eq__(self, other):
11767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11768 
 
11769 
  def __ne__(self, other):
11770 
    return not (self == other)
11771 
 
11772 
class markOrderDoaRequestAuthorized_result:
11773 
  """
11774 
  Attributes:
11775 
   - success
11776 
   - ex
11777 
  """
11778 
 
11779 
  thrift_spec = (
11780 
    (0, TType.BOOL, 'success', None, None, ), # 0
11781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11782 
  )
11783 
 
11784 
  def __init__(self, success=None, ex=None,):
11785 
    self.success = success
11786 
    self.ex = ex
11787 
 
11788 
  def read(self, iprot):
11789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11791 
      return
11792 
    iprot.readStructBegin()
11793 
    while True:
11794 
      (fname, ftype, fid) = iprot.readFieldBegin()
11795 
      if ftype == TType.STOP:
11796 
        break
11797 
      if fid == 0:
11798 
        if ftype == TType.BOOL:
11799 
          self.success = iprot.readBool();
11800 
        else:
11801 
          iprot.skip(ftype)
11802 
      elif fid == 1:
11803 
        if ftype == TType.STRUCT:
11804 
          self.ex = TransactionServiceException()
11805 
          self.ex.read(iprot)
11806 
        else:
11807 
          iprot.skip(ftype)
11808 
      else:
11809 
        iprot.skip(ftype)
11810 
      iprot.readFieldEnd()
11811 
    iprot.readStructEnd()
11812 
 
11813 
  def write(self, oprot):
11814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11816 
      return
11817 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11818 
    if self.success is not None:
11819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11820 
      oprot.writeBool(self.success)
11821 
      oprot.writeFieldEnd()
11822 
    if self.ex is not None:
11823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11824 
      self.ex.write(oprot)
11825 
      oprot.writeFieldEnd()
11826 
    oprot.writeFieldStop()
11827 
    oprot.writeStructEnd()
11828 
 
11829 
  def validate(self):
11830 
    return
11831 
 
11832 
 
11833 
  def __repr__(self):
11834 
    L = ['%s=%r' % (key, value)
11835 
      for key, value in self.__dict__.iteritems()]
11836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11837 
 
11838 
  def __eq__(self, other):
11839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11840 
 
11841 
  def __ne__(self, other):
11842 
    return not (self == other)
11843 
 
4488 rajveer 11844 
class markOrderReturnRequestReceived_args:
11845 
  """
11846 
  Attributes:
11847 
   - orderId
11848 
  """
11849 
 
11850 
  thrift_spec = (
11851 
    None, # 0
11852 
    (1, TType.I64, 'orderId', None, None, ), # 1
11853 
  )
11854 
 
11855 
  def __init__(self, orderId=None,):
11856 
    self.orderId = orderId
11857 
 
11858 
  def read(self, iprot):
11859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11861 
      return
11862 
    iprot.readStructBegin()
11863 
    while True:
11864 
      (fname, ftype, fid) = iprot.readFieldBegin()
11865 
      if ftype == TType.STOP:
11866 
        break
11867 
      if fid == 1:
11868 
        if ftype == TType.I64:
11869 
          self.orderId = iprot.readI64();
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      else:
11873 
        iprot.skip(ftype)
11874 
      iprot.readFieldEnd()
11875 
    iprot.readStructEnd()
11876 
 
11877 
  def write(self, oprot):
11878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11880 
      return
11881 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11882 
    if self.orderId is not None:
11883 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11884 
      oprot.writeI64(self.orderId)
11885 
      oprot.writeFieldEnd()
11886 
    oprot.writeFieldStop()
11887 
    oprot.writeStructEnd()
11888 
 
11889 
  def validate(self):
11890 
    return
11891 
 
11892 
 
11893 
  def __repr__(self):
11894 
    L = ['%s=%r' % (key, value)
11895 
      for key, value in self.__dict__.iteritems()]
11896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11897 
 
11898 
  def __eq__(self, other):
11899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11900 
 
11901 
  def __ne__(self, other):
11902 
    return not (self == other)
11903 
 
11904 
class markOrderReturnRequestReceived_result:
11905 
  """
11906 
  Attributes:
11907 
   - success
11908 
   - ex
11909 
  """
11910 
 
11911 
  thrift_spec = (
11912 
    (0, TType.BOOL, 'success', None, None, ), # 0
11913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11914 
  )
11915 
 
11916 
  def __init__(self, success=None, ex=None,):
11917 
    self.success = success
11918 
    self.ex = ex
11919 
 
11920 
  def read(self, iprot):
11921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11923 
      return
11924 
    iprot.readStructBegin()
11925 
    while True:
11926 
      (fname, ftype, fid) = iprot.readFieldBegin()
11927 
      if ftype == TType.STOP:
11928 
        break
11929 
      if fid == 0:
11930 
        if ftype == TType.BOOL:
11931 
          self.success = iprot.readBool();
11932 
        else:
11933 
          iprot.skip(ftype)
11934 
      elif fid == 1:
11935 
        if ftype == TType.STRUCT:
11936 
          self.ex = TransactionServiceException()
11937 
          self.ex.read(iprot)
11938 
        else:
11939 
          iprot.skip(ftype)
11940 
      else:
11941 
        iprot.skip(ftype)
11942 
      iprot.readFieldEnd()
11943 
    iprot.readStructEnd()
11944 
 
11945 
  def write(self, oprot):
11946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11948 
      return
11949 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11950 
    if self.success is not None:
11951 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11952 
      oprot.writeBool(self.success)
11953 
      oprot.writeFieldEnd()
11954 
    if self.ex is not None:
11955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11956 
      self.ex.write(oprot)
11957 
      oprot.writeFieldEnd()
11958 
    oprot.writeFieldStop()
11959 
    oprot.writeStructEnd()
11960 
 
11961 
  def validate(self):
11962 
    return
11963 
 
11964 
 
11965 
  def __repr__(self):
11966 
    L = ['%s=%r' % (key, value)
11967 
      for key, value in self.__dict__.iteritems()]
11968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11969 
 
11970 
  def __eq__(self, other):
11971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11972 
 
11973 
  def __ne__(self, other):
11974 
    return not (self == other)
11975 
 
11976 
class markOrderReturnRequestAuthorized_args:
11977 
  """
11978 
  Attributes:
11979 
   - orderId
11980 
   - isAuthorized
11981 
  """
11982 
 
11983 
  thrift_spec = (
11984 
    None, # 0
11985 
    (1, TType.I64, 'orderId', None, None, ), # 1
11986 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11987 
  )
11988 
 
11989 
  def __init__(self, orderId=None, isAuthorized=None,):
11990 
    self.orderId = orderId
11991 
    self.isAuthorized = isAuthorized
11992 
 
11993 
  def read(self, iprot):
11994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11996 
      return
11997 
    iprot.readStructBegin()
11998 
    while True:
11999 
      (fname, ftype, fid) = iprot.readFieldBegin()
12000 
      if ftype == TType.STOP:
12001 
        break
12002 
      if fid == 1:
12003 
        if ftype == TType.I64:
12004 
          self.orderId = iprot.readI64();
12005 
        else:
12006 
          iprot.skip(ftype)
12007 
      elif fid == 2:
12008 
        if ftype == TType.BOOL:
12009 
          self.isAuthorized = iprot.readBool();
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      else:
12013 
        iprot.skip(ftype)
12014 
      iprot.readFieldEnd()
12015 
    iprot.readStructEnd()
12016 
 
12017 
  def write(self, oprot):
12018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12020 
      return
12021 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12022 
    if self.orderId is not None:
12023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12024 
      oprot.writeI64(self.orderId)
12025 
      oprot.writeFieldEnd()
12026 
    if self.isAuthorized is not None:
12027 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12028 
      oprot.writeBool(self.isAuthorized)
12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
12047 
 
12048 
class markOrderReturnRequestAuthorized_result:
12049 
  """
12050 
  Attributes:
12051 
   - success
12052 
   - ex
12053 
  """
12054 
 
12055 
  thrift_spec = (
12056 
    (0, TType.BOOL, 'success', None, None, ), # 0
12057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12058 
  )
12059 
 
12060 
  def __init__(self, success=None, ex=None,):
12061 
    self.success = success
12062 
    self.ex = ex
12063 
 
12064 
  def read(self, iprot):
12065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12067 
      return
12068 
    iprot.readStructBegin()
12069 
    while True:
12070 
      (fname, ftype, fid) = iprot.readFieldBegin()
12071 
      if ftype == TType.STOP:
12072 
        break
12073 
      if fid == 0:
12074 
        if ftype == TType.BOOL:
12075 
          self.success = iprot.readBool();
12076 
        else:
12077 
          iprot.skip(ftype)
12078 
      elif fid == 1:
12079 
        if ftype == TType.STRUCT:
12080 
          self.ex = TransactionServiceException()
12081 
          self.ex.read(iprot)
12082 
        else:
12083 
          iprot.skip(ftype)
12084 
      else:
12085 
        iprot.skip(ftype)
12086 
      iprot.readFieldEnd()
12087 
    iprot.readStructEnd()
12088 
 
12089 
  def write(self, oprot):
12090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12092 
      return
12093 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12094 
    if self.success is not None:
12095 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12096 
      oprot.writeBool(self.success)
12097 
      oprot.writeFieldEnd()
12098 
    if self.ex is not None:
12099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12100 
      self.ex.write(oprot)
12101 
      oprot.writeFieldEnd()
12102 
    oprot.writeFieldStop()
12103 
    oprot.writeStructEnd()
12104 
 
12105 
  def validate(self):
12106 
    return
12107 
 
12108 
 
12109 
  def __repr__(self):
12110 
    L = ['%s=%r' % (key, value)
12111 
      for key, value in self.__dict__.iteritems()]
12112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12113 
 
12114 
  def __eq__(self, other):
12115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12116 
 
12117 
  def __ne__(self, other):
12118 
    return not (self == other)
12119 
 
2536 chandransh 12120 
class requestPickupNumber_args:
12121 
  """
12122 
  Attributes:
12123 
   - orderId
4579 rajveer 12124 
   - providerId
2536 chandransh 12125 
  """
12126 
 
12127 
  thrift_spec = (
12128 
    None, # 0
12129 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12130 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12131 
  )
12132 
 
4579 rajveer 12133 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12134 
    self.orderId = orderId
4579 rajveer 12135 
    self.providerId = providerId
2536 chandransh 12136 
 
12137 
  def read(self, iprot):
12138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12140 
      return
12141 
    iprot.readStructBegin()
12142 
    while True:
12143 
      (fname, ftype, fid) = iprot.readFieldBegin()
12144 
      if ftype == TType.STOP:
12145 
        break
12146 
      if fid == 1:
12147 
        if ftype == TType.I64:
12148 
          self.orderId = iprot.readI64();
12149 
        else:
12150 
          iprot.skip(ftype)
4579 rajveer 12151 
      elif fid == 2:
12152 
        if ftype == TType.I64:
12153 
          self.providerId = iprot.readI64();
12154 
        else:
12155 
          iprot.skip(ftype)
2536 chandransh 12156 
      else:
12157 
        iprot.skip(ftype)
12158 
      iprot.readFieldEnd()
12159 
    iprot.readStructEnd()
12160 
 
12161 
  def write(self, oprot):
12162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12164 
      return
12165 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12166 
    if self.orderId is not None:
2536 chandransh 12167 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12168 
      oprot.writeI64(self.orderId)
12169 
      oprot.writeFieldEnd()
4579 rajveer 12170 
    if self.providerId is not None:
12171 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12172 
      oprot.writeI64(self.providerId)
12173 
      oprot.writeFieldEnd()
2536 chandransh 12174 
    oprot.writeFieldStop()
12175 
    oprot.writeStructEnd()
12176 
 
3431 rajveer 12177 
  def validate(self):
12178 
    return
12179 
 
12180 
 
2536 chandransh 12181 
  def __repr__(self):
12182 
    L = ['%s=%r' % (key, value)
12183 
      for key, value in self.__dict__.iteritems()]
12184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12185 
 
12186 
  def __eq__(self, other):
12187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12188 
 
12189 
  def __ne__(self, other):
12190 
    return not (self == other)
12191 
 
12192 
class requestPickupNumber_result:
12193 
  """
12194 
  Attributes:
12195 
   - success
12196 
   - ex
12197 
  """
12198 
 
12199 
  thrift_spec = (
12200 
    (0, TType.BOOL, 'success', None, None, ), # 0
12201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12202 
  )
12203 
 
12204 
  def __init__(self, success=None, ex=None,):
12205 
    self.success = success
12206 
    self.ex = ex
12207 
 
12208 
  def read(self, iprot):
12209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12211 
      return
12212 
    iprot.readStructBegin()
12213 
    while True:
12214 
      (fname, ftype, fid) = iprot.readFieldBegin()
12215 
      if ftype == TType.STOP:
12216 
        break
12217 
      if fid == 0:
12218 
        if ftype == TType.BOOL:
12219 
          self.success = iprot.readBool();
12220 
        else:
12221 
          iprot.skip(ftype)
12222 
      elif fid == 1:
12223 
        if ftype == TType.STRUCT:
12224 
          self.ex = TransactionServiceException()
12225 
          self.ex.read(iprot)
12226 
        else:
12227 
          iprot.skip(ftype)
12228 
      else:
12229 
        iprot.skip(ftype)
12230 
      iprot.readFieldEnd()
12231 
    iprot.readStructEnd()
12232 
 
12233 
  def write(self, oprot):
12234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12236 
      return
12237 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12238 
    if self.success is not None:
2536 chandransh 12239 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12240 
      oprot.writeBool(self.success)
12241 
      oprot.writeFieldEnd()
3431 rajveer 12242 
    if self.ex is not None:
2536 chandransh 12243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12244 
      self.ex.write(oprot)
12245 
      oprot.writeFieldEnd()
12246 
    oprot.writeFieldStop()
12247 
    oprot.writeStructEnd()
12248 
 
3431 rajveer 12249 
  def validate(self):
12250 
    return
12251 
 
12252 
 
2536 chandransh 12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
12264 
class authorizePickup_args:
12265 
  """
12266 
  Attributes:
12267 
   - orderId
12268 
   - pickupNumber
4602 rajveer 12269 
   - providerId
2536 chandransh 12270 
  """
12271 
 
12272 
  thrift_spec = (
12273 
    None, # 0
12274 
    (1, TType.I64, 'orderId', None, None, ), # 1
12275 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12276 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12277 
  )
12278 
 
4602 rajveer 12279 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12280 
    self.orderId = orderId
12281 
    self.pickupNumber = pickupNumber
4602 rajveer 12282 
    self.providerId = providerId
2536 chandransh 12283 
 
12284 
  def read(self, iprot):
12285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12287 
      return
12288 
    iprot.readStructBegin()
12289 
    while True:
12290 
      (fname, ftype, fid) = iprot.readFieldBegin()
12291 
      if ftype == TType.STOP:
12292 
        break
12293 
      if fid == 1:
12294 
        if ftype == TType.I64:
12295 
          self.orderId = iprot.readI64();
12296 
        else:
12297 
          iprot.skip(ftype)
12298 
      elif fid == 2:
12299 
        if ftype == TType.STRING:
12300 
          self.pickupNumber = iprot.readString();
12301 
        else:
12302 
          iprot.skip(ftype)
4602 rajveer 12303 
      elif fid == 3:
12304 
        if ftype == TType.I64:
12305 
          self.providerId = iprot.readI64();
12306 
        else:
12307 
          iprot.skip(ftype)
2536 chandransh 12308 
      else:
12309 
        iprot.skip(ftype)
12310 
      iprot.readFieldEnd()
12311 
    iprot.readStructEnd()
12312 
 
12313 
  def write(self, oprot):
12314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12316 
      return
12317 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12318 
    if self.orderId is not None:
2536 chandransh 12319 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12320 
      oprot.writeI64(self.orderId)
12321 
      oprot.writeFieldEnd()
3431 rajveer 12322 
    if self.pickupNumber is not None:
2536 chandransh 12323 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12324 
      oprot.writeString(self.pickupNumber)
12325 
      oprot.writeFieldEnd()
4602 rajveer 12326 
    if self.providerId is not None:
12327 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12328 
      oprot.writeI64(self.providerId)
12329 
      oprot.writeFieldEnd()
2536 chandransh 12330 
    oprot.writeFieldStop()
12331 
    oprot.writeStructEnd()
12332 
 
3431 rajveer 12333 
  def validate(self):
12334 
    return
12335 
 
12336 
 
2536 chandransh 12337 
  def __repr__(self):
12338 
    L = ['%s=%r' % (key, value)
12339 
      for key, value in self.__dict__.iteritems()]
12340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12341 
 
12342 
  def __eq__(self, other):
12343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12344 
 
12345 
  def __ne__(self, other):
12346 
    return not (self == other)
12347 
 
12348 
class authorizePickup_result:
12349 
  """
12350 
  Attributes:
12351 
   - success
12352 
   - ex
12353 
  """
12354 
 
12355 
  thrift_spec = (
12356 
    (0, TType.BOOL, 'success', None, None, ), # 0
12357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12358 
  )
12359 
 
12360 
  def __init__(self, success=None, ex=None,):
12361 
    self.success = success
12362 
    self.ex = ex
12363 
 
12364 
  def read(self, iprot):
12365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12367 
      return
12368 
    iprot.readStructBegin()
12369 
    while True:
12370 
      (fname, ftype, fid) = iprot.readFieldBegin()
12371 
      if ftype == TType.STOP:
12372 
        break
12373 
      if fid == 0:
12374 
        if ftype == TType.BOOL:
12375 
          self.success = iprot.readBool();
12376 
        else:
12377 
          iprot.skip(ftype)
12378 
      elif fid == 1:
12379 
        if ftype == TType.STRUCT:
12380 
          self.ex = TransactionServiceException()
12381 
          self.ex.read(iprot)
12382 
        else:
12383 
          iprot.skip(ftype)
12384 
      else:
12385 
        iprot.skip(ftype)
12386 
      iprot.readFieldEnd()
12387 
    iprot.readStructEnd()
12388 
 
12389 
  def write(self, oprot):
12390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12392 
      return
12393 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12394 
    if self.success is not None:
2536 chandransh 12395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12396 
      oprot.writeBool(self.success)
12397 
      oprot.writeFieldEnd()
3431 rajveer 12398 
    if self.ex is not None:
2536 chandransh 12399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12400 
      self.ex.write(oprot)
12401 
      oprot.writeFieldEnd()
12402 
    oprot.writeFieldStop()
12403 
    oprot.writeStructEnd()
12404 
 
3431 rajveer 12405 
  def validate(self):
12406 
    return
12407 
 
12408 
 
2536 chandransh 12409 
  def __repr__(self):
12410 
    L = ['%s=%r' % (key, value)
12411 
      for key, value in self.__dict__.iteritems()]
12412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12413 
 
12414 
  def __eq__(self, other):
12415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12416 
 
12417 
  def __ne__(self, other):
12418 
    return not (self == other)
12419 
 
2764 chandransh 12420 
class markDoasAsPickedUp_args:
12421 
  """
12422 
  Attributes:
12423 
   - providerId
12424 
   - pickupDetails
12425 
  """
12426 
 
12427 
  thrift_spec = (
12428 
    None, # 0
12429 
    (1, TType.I64, 'providerId', None, None, ), # 1
12430 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12431 
  )
12432 
 
12433 
  def __init__(self, providerId=None, pickupDetails=None,):
12434 
    self.providerId = providerId
12435 
    self.pickupDetails = pickupDetails
12436 
 
12437 
  def read(self, iprot):
12438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12440 
      return
12441 
    iprot.readStructBegin()
12442 
    while True:
12443 
      (fname, ftype, fid) = iprot.readFieldBegin()
12444 
      if ftype == TType.STOP:
12445 
        break
12446 
      if fid == 1:
12447 
        if ftype == TType.I64:
12448 
          self.providerId = iprot.readI64();
12449 
        else:
12450 
          iprot.skip(ftype)
12451 
      elif fid == 2:
12452 
        if ftype == TType.MAP:
12453 
          self.pickupDetails = {}
4581 phani.kuma 12454 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12455 
          for _i201 in xrange(_size197):
12456 
            _key202 = iprot.readString();
12457 
            _val203 = iprot.readString();
12458 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12459 
          iprot.readMapEnd()
12460 
        else:
12461 
          iprot.skip(ftype)
12462 
      else:
12463 
        iprot.skip(ftype)
12464 
      iprot.readFieldEnd()
12465 
    iprot.readStructEnd()
12466 
 
12467 
  def write(self, oprot):
12468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12470 
      return
12471 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12472 
    if self.providerId is not None:
2764 chandransh 12473 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12474 
      oprot.writeI64(self.providerId)
12475 
      oprot.writeFieldEnd()
3431 rajveer 12476 
    if self.pickupDetails is not None:
2764 chandransh 12477 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12478 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12479 
      for kiter204,viter205 in self.pickupDetails.items():
12480 
        oprot.writeString(kiter204)
12481 
        oprot.writeString(viter205)
2764 chandransh 12482 
      oprot.writeMapEnd()
12483 
      oprot.writeFieldEnd()
12484 
    oprot.writeFieldStop()
12485 
    oprot.writeStructEnd()
12486 
 
3431 rajveer 12487 
  def validate(self):
12488 
    return
12489 
 
12490 
 
2764 chandransh 12491 
  def __repr__(self):
12492 
    L = ['%s=%r' % (key, value)
12493 
      for key, value in self.__dict__.iteritems()]
12494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12495 
 
12496 
  def __eq__(self, other):
12497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12498 
 
12499 
  def __ne__(self, other):
12500 
    return not (self == other)
12501 
 
12502 
class markDoasAsPickedUp_result:
12503 
  """
12504 
  Attributes:
12505 
   - success
12506 
  """
12507 
 
12508 
  thrift_spec = (
12509 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12510 
  )
12511 
 
12512 
  def __init__(self, success=None,):
12513 
    self.success = success
12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 0:
12525 
        if ftype == TType.LIST:
12526 
          self.success = []
4581 phani.kuma 12527 
          (_etype209, _size206) = iprot.readListBegin()
12528 
          for _i210 in xrange(_size206):
12529 
            _elem211 = Order()
12530 
            _elem211.read(iprot)
12531 
            self.success.append(_elem211)
2764 chandransh 12532 
          iprot.readListEnd()
12533 
        else:
12534 
          iprot.skip(ftype)
12535 
      else:
12536 
        iprot.skip(ftype)
12537 
      iprot.readFieldEnd()
12538 
    iprot.readStructEnd()
12539 
 
12540 
  def write(self, oprot):
12541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12543 
      return
12544 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12545 
    if self.success is not None:
2764 chandransh 12546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12548 
      for iter212 in self.success:
12549 
        iter212.write(oprot)
2764 chandransh 12550 
      oprot.writeListEnd()
12551 
      oprot.writeFieldEnd()
12552 
    oprot.writeFieldStop()
12553 
    oprot.writeStructEnd()
12554 
 
3431 rajveer 12555 
  def validate(self):
12556 
    return
12557 
 
12558 
 
2764 chandransh 12559 
  def __repr__(self):
12560 
    L = ['%s=%r' % (key, value)
12561 
      for key, value in self.__dict__.iteritems()]
12562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12563 
 
12564 
  def __eq__(self, other):
12565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12566 
 
12567 
  def __ne__(self, other):
12568 
    return not (self == other)
12569 
 
2616 chandransh 12570 
class receiveReturn_args:
2591 chandransh 12571 
  """
12572 
  Attributes:
12573 
   - orderId
4479 rajveer 12574 
   - receiveCondition
2591 chandransh 12575 
  """
2536 chandransh 12576 
 
2591 chandransh 12577 
  thrift_spec = (
12578 
    None, # 0
12579 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12580 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12581 
  )
12582 
 
4479 rajveer 12583 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12584 
    self.orderId = orderId
4479 rajveer 12585 
    self.receiveCondition = receiveCondition
2591 chandransh 12586 
 
12587 
  def read(self, iprot):
12588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12590 
      return
12591 
    iprot.readStructBegin()
12592 
    while True:
12593 
      (fname, ftype, fid) = iprot.readFieldBegin()
12594 
      if ftype == TType.STOP:
12595 
        break
12596 
      if fid == 1:
12597 
        if ftype == TType.I64:
12598 
          self.orderId = iprot.readI64();
12599 
        else:
12600 
          iprot.skip(ftype)
4479 rajveer 12601 
      elif fid == 2:
12602 
        if ftype == TType.I64:
12603 
          self.receiveCondition = iprot.readI64();
12604 
        else:
12605 
          iprot.skip(ftype)
2591 chandransh 12606 
      else:
12607 
        iprot.skip(ftype)
12608 
      iprot.readFieldEnd()
12609 
    iprot.readStructEnd()
12610 
 
12611 
  def write(self, oprot):
12612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12614 
      return
2616 chandransh 12615 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12616 
    if self.orderId is not None:
2591 chandransh 12617 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12618 
      oprot.writeI64(self.orderId)
12619 
      oprot.writeFieldEnd()
4479 rajveer 12620 
    if self.receiveCondition is not None:
12621 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12622 
      oprot.writeI64(self.receiveCondition)
12623 
      oprot.writeFieldEnd()
2591 chandransh 12624 
    oprot.writeFieldStop()
12625 
    oprot.writeStructEnd()
12626 
 
3431 rajveer 12627 
  def validate(self):
12628 
    return
12629 
 
12630 
 
2591 chandransh 12631 
  def __repr__(self):
12632 
    L = ['%s=%r' % (key, value)
12633 
      for key, value in self.__dict__.iteritems()]
12634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12635 
 
12636 
  def __eq__(self, other):
12637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12638 
 
12639 
  def __ne__(self, other):
12640 
    return not (self == other)
12641 
 
2616 chandransh 12642 
class receiveReturn_result:
2591 chandransh 12643 
  """
12644 
  Attributes:
12645 
   - success
12646 
   - ex
12647 
  """
12648 
 
12649 
  thrift_spec = (
12650 
    (0, TType.BOOL, 'success', None, None, ), # 0
12651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12652 
  )
12653 
 
12654 
  def __init__(self, success=None, ex=None,):
12655 
    self.success = success
12656 
    self.ex = ex
12657 
 
12658 
  def read(self, iprot):
12659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12661 
      return
12662 
    iprot.readStructBegin()
12663 
    while True:
12664 
      (fname, ftype, fid) = iprot.readFieldBegin()
12665 
      if ftype == TType.STOP:
12666 
        break
12667 
      if fid == 0:
12668 
        if ftype == TType.BOOL:
12669 
          self.success = iprot.readBool();
12670 
        else:
12671 
          iprot.skip(ftype)
12672 
      elif fid == 1:
12673 
        if ftype == TType.STRUCT:
12674 
          self.ex = TransactionServiceException()
12675 
          self.ex.read(iprot)
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      else:
12679 
        iprot.skip(ftype)
12680 
      iprot.readFieldEnd()
12681 
    iprot.readStructEnd()
12682 
 
12683 
  def write(self, oprot):
12684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12686 
      return
2616 chandransh 12687 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12688 
    if self.success is not None:
2591 chandransh 12689 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12690 
      oprot.writeBool(self.success)
12691 
      oprot.writeFieldEnd()
3431 rajveer 12692 
    if self.ex is not None:
2591 chandransh 12693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12694 
      self.ex.write(oprot)
12695 
      oprot.writeFieldEnd()
12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
3431 rajveer 12699 
  def validate(self):
12700 
    return
12701 
 
12702 
 
2591 chandransh 12703 
  def __repr__(self):
12704 
    L = ['%s=%r' % (key, value)
12705 
      for key, value in self.__dict__.iteritems()]
12706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12707 
 
12708 
  def __eq__(self, other):
12709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12710 
 
12711 
  def __ne__(self, other):
12712 
    return not (self == other)
12713 
 
12714 
class validateDoa_args:
12715 
  """
12716 
  Attributes:
12717 
   - orderId
12718 
   - isValid
12719 
  """
12720 
 
12721 
  thrift_spec = (
12722 
    None, # 0
12723 
    (1, TType.I64, 'orderId', None, None, ), # 1
12724 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12725 
  )
12726 
 
12727 
  def __init__(self, orderId=None, isValid=None,):
12728 
    self.orderId = orderId
12729 
    self.isValid = isValid
12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
12740 
      if fid == 1:
12741 
        if ftype == TType.I64:
12742 
          self.orderId = iprot.readI64();
12743 
        else:
12744 
          iprot.skip(ftype)
12745 
      elif fid == 2:
12746 
        if ftype == TType.BOOL:
12747 
          self.isValid = iprot.readBool();
12748 
        else:
12749 
          iprot.skip(ftype)
12750 
      else:
12751 
        iprot.skip(ftype)
12752 
      iprot.readFieldEnd()
12753 
    iprot.readStructEnd()
12754 
 
12755 
  def write(self, oprot):
12756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12758 
      return
12759 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12760 
    if self.orderId is not None:
2591 chandransh 12761 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12762 
      oprot.writeI64(self.orderId)
12763 
      oprot.writeFieldEnd()
3431 rajveer 12764 
    if self.isValid is not None:
2591 chandransh 12765 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12766 
      oprot.writeBool(self.isValid)
12767 
      oprot.writeFieldEnd()
12768 
    oprot.writeFieldStop()
12769 
    oprot.writeStructEnd()
12770 
 
3431 rajveer 12771 
  def validate(self):
12772 
    return
12773 
 
12774 
 
2591 chandransh 12775 
  def __repr__(self):
12776 
    L = ['%s=%r' % (key, value)
12777 
      for key, value in self.__dict__.iteritems()]
12778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12779 
 
12780 
  def __eq__(self, other):
12781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12782 
 
12783 
  def __ne__(self, other):
12784 
    return not (self == other)
12785 
 
12786 
class validateDoa_result:
12787 
  """
12788 
  Attributes:
12789 
   - success
12790 
   - ex
12791 
  """
12792 
 
12793 
  thrift_spec = (
12794 
    (0, TType.BOOL, 'success', None, None, ), # 0
12795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12796 
  )
12797 
 
12798 
  def __init__(self, success=None, ex=None,):
12799 
    self.success = success
12800 
    self.ex = ex
12801 
 
12802 
  def read(self, iprot):
12803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12805 
      return
12806 
    iprot.readStructBegin()
12807 
    while True:
12808 
      (fname, ftype, fid) = iprot.readFieldBegin()
12809 
      if ftype == TType.STOP:
12810 
        break
12811 
      if fid == 0:
12812 
        if ftype == TType.BOOL:
12813 
          self.success = iprot.readBool();
12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      elif fid == 1:
12817 
        if ftype == TType.STRUCT:
12818 
          self.ex = TransactionServiceException()
12819 
          self.ex.read(iprot)
12820 
        else:
12821 
          iprot.skip(ftype)
12822 
      else:
12823 
        iprot.skip(ftype)
12824 
      iprot.readFieldEnd()
12825 
    iprot.readStructEnd()
12826 
 
12827 
  def write(self, oprot):
12828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12830 
      return
12831 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12832 
    if self.success is not None:
2591 chandransh 12833 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12834 
      oprot.writeBool(self.success)
12835 
      oprot.writeFieldEnd()
3431 rajveer 12836 
    if self.ex is not None:
2591 chandransh 12837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12838 
      self.ex.write(oprot)
12839 
      oprot.writeFieldEnd()
12840 
    oprot.writeFieldStop()
12841 
    oprot.writeStructEnd()
12842 
 
3431 rajveer 12843 
  def validate(self):
12844 
    return
12845 
 
12846 
 
2591 chandransh 12847 
  def __repr__(self):
12848 
    L = ['%s=%r' % (key, value)
12849 
      for key, value in self.__dict__.iteritems()]
12850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12851 
 
12852 
  def __eq__(self, other):
12853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12854 
 
12855 
  def __ne__(self, other):
12856 
    return not (self == other)
12857 
 
4495 rajveer 12858 
class validateReturnProduct_args:
12859 
  """
12860 
  Attributes:
12861 
   - orderId
12862 
   - isUsable
12863 
  """
12864 
 
12865 
  thrift_spec = (
12866 
    None, # 0
12867 
    (1, TType.I64, 'orderId', None, None, ), # 1
12868 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12869 
  )
12870 
 
12871 
  def __init__(self, orderId=None, isUsable=None,):
12872 
    self.orderId = orderId
12873 
    self.isUsable = isUsable
12874 
 
12875 
  def read(self, iprot):
12876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12878 
      return
12879 
    iprot.readStructBegin()
12880 
    while True:
12881 
      (fname, ftype, fid) = iprot.readFieldBegin()
12882 
      if ftype == TType.STOP:
12883 
        break
12884 
      if fid == 1:
12885 
        if ftype == TType.I64:
12886 
          self.orderId = iprot.readI64();
12887 
        else:
12888 
          iprot.skip(ftype)
12889 
      elif fid == 2:
12890 
        if ftype == TType.BOOL:
12891 
          self.isUsable = iprot.readBool();
12892 
        else:
12893 
          iprot.skip(ftype)
12894 
      else:
12895 
        iprot.skip(ftype)
12896 
      iprot.readFieldEnd()
12897 
    iprot.readStructEnd()
12898 
 
12899 
  def write(self, oprot):
12900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12902 
      return
12903 
    oprot.writeStructBegin('validateReturnProduct_args')
12904 
    if self.orderId is not None:
12905 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12906 
      oprot.writeI64(self.orderId)
12907 
      oprot.writeFieldEnd()
12908 
    if self.isUsable is not None:
12909 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12910 
      oprot.writeBool(self.isUsable)
12911 
      oprot.writeFieldEnd()
12912 
    oprot.writeFieldStop()
12913 
    oprot.writeStructEnd()
12914 
 
12915 
  def validate(self):
12916 
    return
12917 
 
12918 
 
12919 
  def __repr__(self):
12920 
    L = ['%s=%r' % (key, value)
12921 
      for key, value in self.__dict__.iteritems()]
12922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12923 
 
12924 
  def __eq__(self, other):
12925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12926 
 
12927 
  def __ne__(self, other):
12928 
    return not (self == other)
12929 
 
12930 
class validateReturnProduct_result:
12931 
  """
12932 
  Attributes:
12933 
   - success
12934 
   - ex
12935 
  """
12936 
 
12937 
  thrift_spec = (
12938 
    (0, TType.BOOL, 'success', None, None, ), # 0
12939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12940 
  )
12941 
 
12942 
  def __init__(self, success=None, ex=None,):
12943 
    self.success = success
12944 
    self.ex = ex
12945 
 
12946 
  def read(self, iprot):
12947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12949 
      return
12950 
    iprot.readStructBegin()
12951 
    while True:
12952 
      (fname, ftype, fid) = iprot.readFieldBegin()
12953 
      if ftype == TType.STOP:
12954 
        break
12955 
      if fid == 0:
12956 
        if ftype == TType.BOOL:
12957 
          self.success = iprot.readBool();
12958 
        else:
12959 
          iprot.skip(ftype)
12960 
      elif fid == 1:
12961 
        if ftype == TType.STRUCT:
12962 
          self.ex = TransactionServiceException()
12963 
          self.ex.read(iprot)
12964 
        else:
12965 
          iprot.skip(ftype)
12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
12975 
    oprot.writeStructBegin('validateReturnProduct_result')
12976 
    if self.success is not None:
12977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12978 
      oprot.writeBool(self.success)
12979 
      oprot.writeFieldEnd()
12980 
    if self.ex is not None:
12981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12982 
      self.ex.write(oprot)
12983 
      oprot.writeFieldEnd()
12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
2616 chandransh 13002 
class reshipOrder_args:
13003 
  """
13004 
  Attributes:
13005 
   - orderId
13006 
  """
2591 chandransh 13007 
 
2616 chandransh 13008 
  thrift_spec = (
13009 
    None, # 0
13010 
    (1, TType.I64, 'orderId', None, None, ), # 1
13011 
  )
13012 
 
13013 
  def __init__(self, orderId=None,):
13014 
    self.orderId = orderId
13015 
 
13016 
  def read(self, iprot):
13017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13019 
      return
13020 
    iprot.readStructBegin()
13021 
    while True:
13022 
      (fname, ftype, fid) = iprot.readFieldBegin()
13023 
      if ftype == TType.STOP:
13024 
        break
13025 
      if fid == 1:
13026 
        if ftype == TType.I64:
13027 
          self.orderId = iprot.readI64();
13028 
        else:
13029 
          iprot.skip(ftype)
13030 
      else:
13031 
        iprot.skip(ftype)
13032 
      iprot.readFieldEnd()
13033 
    iprot.readStructEnd()
13034 
 
13035 
  def write(self, oprot):
13036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13038 
      return
13039 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13040 
    if self.orderId is not None:
2616 chandransh 13041 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13042 
      oprot.writeI64(self.orderId)
13043 
      oprot.writeFieldEnd()
13044 
    oprot.writeFieldStop()
13045 
    oprot.writeStructEnd()
13046 
 
3431 rajveer 13047 
  def validate(self):
13048 
    return
13049 
 
13050 
 
2616 chandransh 13051 
  def __repr__(self):
13052 
    L = ['%s=%r' % (key, value)
13053 
      for key, value in self.__dict__.iteritems()]
13054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13055 
 
13056 
  def __eq__(self, other):
13057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13058 
 
13059 
  def __ne__(self, other):
13060 
    return not (self == other)
13061 
 
13062 
class reshipOrder_result:
13063 
  """
13064 
  Attributes:
13065 
   - success
13066 
   - ex
13067 
  """
13068 
 
13069 
  thrift_spec = (
13070 
    (0, TType.I64, 'success', None, None, ), # 0
13071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13072 
  )
13073 
 
13074 
  def __init__(self, success=None, ex=None,):
13075 
    self.success = success
13076 
    self.ex = ex
13077 
 
13078 
  def read(self, iprot):
13079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13081 
      return
13082 
    iprot.readStructBegin()
13083 
    while True:
13084 
      (fname, ftype, fid) = iprot.readFieldBegin()
13085 
      if ftype == TType.STOP:
13086 
        break
13087 
      if fid == 0:
13088 
        if ftype == TType.I64:
13089 
          self.success = iprot.readI64();
13090 
        else:
13091 
          iprot.skip(ftype)
13092 
      elif fid == 1:
13093 
        if ftype == TType.STRUCT:
13094 
          self.ex = TransactionServiceException()
13095 
          self.ex.read(iprot)
13096 
        else:
13097 
          iprot.skip(ftype)
13098 
      else:
13099 
        iprot.skip(ftype)
13100 
      iprot.readFieldEnd()
13101 
    iprot.readStructEnd()
13102 
 
13103 
  def write(self, oprot):
13104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13106 
      return
13107 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13108 
    if self.success is not None:
2616 chandransh 13109 
      oprot.writeFieldBegin('success', TType.I64, 0)
13110 
      oprot.writeI64(self.success)
13111 
      oprot.writeFieldEnd()
3431 rajveer 13112 
    if self.ex is not None:
2616 chandransh 13113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13114 
      self.ex.write(oprot)
13115 
      oprot.writeFieldEnd()
13116 
    oprot.writeFieldStop()
13117 
    oprot.writeStructEnd()
13118 
 
3431 rajveer 13119 
  def validate(self):
13120 
    return
13121 
 
13122 
 
2616 chandransh 13123 
  def __repr__(self):
13124 
    L = ['%s=%r' % (key, value)
13125 
      for key, value in self.__dict__.iteritems()]
13126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13127 
 
13128 
  def __eq__(self, other):
13129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13130 
 
13131 
  def __ne__(self, other):
13132 
    return not (self == other)
13133 
 
13134 
class refundOrder_args:
13135 
  """
13136 
  Attributes:
13137 
   - orderId
3226 chandransh 13138 
   - refundedBy
13139 
   - reason
2616 chandransh 13140 
  """
13141 
 
13142 
  thrift_spec = (
13143 
    None, # 0
13144 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13145 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13146 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13147 
  )
13148 
 
3226 chandransh 13149 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13150 
    self.orderId = orderId
3226 chandransh 13151 
    self.refundedBy = refundedBy
13152 
    self.reason = reason
2616 chandransh 13153 
 
13154 
  def read(self, iprot):
13155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13157 
      return
13158 
    iprot.readStructBegin()
13159 
    while True:
13160 
      (fname, ftype, fid) = iprot.readFieldBegin()
13161 
      if ftype == TType.STOP:
13162 
        break
13163 
      if fid == 1:
13164 
        if ftype == TType.I64:
13165 
          self.orderId = iprot.readI64();
13166 
        else:
13167 
          iprot.skip(ftype)
3226 chandransh 13168 
      elif fid == 2:
13169 
        if ftype == TType.STRING:
13170 
          self.refundedBy = iprot.readString();
13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      elif fid == 3:
13174 
        if ftype == TType.STRING:
13175 
          self.reason = iprot.readString();
13176 
        else:
13177 
          iprot.skip(ftype)
2616 chandransh 13178 
      else:
13179 
        iprot.skip(ftype)
13180 
      iprot.readFieldEnd()
13181 
    iprot.readStructEnd()
13182 
 
13183 
  def write(self, oprot):
13184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13186 
      return
13187 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13188 
    if self.orderId is not None:
2616 chandransh 13189 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13190 
      oprot.writeI64(self.orderId)
13191 
      oprot.writeFieldEnd()
3431 rajveer 13192 
    if self.refundedBy is not None:
3226 chandransh 13193 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13194 
      oprot.writeString(self.refundedBy)
13195 
      oprot.writeFieldEnd()
3431 rajveer 13196 
    if self.reason is not None:
3226 chandransh 13197 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13198 
      oprot.writeString(self.reason)
13199 
      oprot.writeFieldEnd()
2616 chandransh 13200 
    oprot.writeFieldStop()
13201 
    oprot.writeStructEnd()
13202 
 
3431 rajveer 13203 
  def validate(self):
13204 
    return
13205 
 
13206 
 
2616 chandransh 13207 
  def __repr__(self):
13208 
    L = ['%s=%r' % (key, value)
13209 
      for key, value in self.__dict__.iteritems()]
13210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13211 
 
13212 
  def __eq__(self, other):
13213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13214 
 
13215 
  def __ne__(self, other):
13216 
    return not (self == other)
13217 
 
13218 
class refundOrder_result:
13219 
  """
13220 
  Attributes:
13221 
   - success
13222 
   - ex
13223 
  """
13224 
 
13225 
  thrift_spec = (
13226 
    (0, TType.BOOL, 'success', None, None, ), # 0
13227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13228 
  )
13229 
 
13230 
  def __init__(self, success=None, ex=None,):
13231 
    self.success = success
13232 
    self.ex = ex
13233 
 
13234 
  def read(self, iprot):
13235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13237 
      return
13238 
    iprot.readStructBegin()
13239 
    while True:
13240 
      (fname, ftype, fid) = iprot.readFieldBegin()
13241 
      if ftype == TType.STOP:
13242 
        break
13243 
      if fid == 0:
13244 
        if ftype == TType.BOOL:
13245 
          self.success = iprot.readBool();
13246 
        else:
13247 
          iprot.skip(ftype)
13248 
      elif fid == 1:
13249 
        if ftype == TType.STRUCT:
13250 
          self.ex = TransactionServiceException()
13251 
          self.ex.read(iprot)
13252 
        else:
13253 
          iprot.skip(ftype)
13254 
      else:
13255 
        iprot.skip(ftype)
13256 
      iprot.readFieldEnd()
13257 
    iprot.readStructEnd()
13258 
 
13259 
  def write(self, oprot):
13260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13262 
      return
13263 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13264 
    if self.success is not None:
2616 chandransh 13265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13266 
      oprot.writeBool(self.success)
13267 
      oprot.writeFieldEnd()
3431 rajveer 13268 
    if self.ex is not None:
2616 chandransh 13269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13270 
      self.ex.write(oprot)
13271 
      oprot.writeFieldEnd()
13272 
    oprot.writeFieldStop()
13273 
    oprot.writeStructEnd()
13274 
 
3431 rajveer 13275 
  def validate(self):
13276 
    return
13277 
 
13278 
 
2616 chandransh 13279 
  def __repr__(self):
13280 
    L = ['%s=%r' % (key, value)
13281 
      for key, value in self.__dict__.iteritems()]
13282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13283 
 
13284 
  def __eq__(self, other):
13285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13286 
 
13287 
  def __ne__(self, other):
13288 
    return not (self == other)
13289 
 
2690 chandransh 13290 
class getReturnOrders_args:
13291 
  """
13292 
  Attributes:
13293 
   - warehouseId
13294 
   - fromDate
13295 
   - toDate
13296 
  """
2616 chandransh 13297 
 
2690 chandransh 13298 
  thrift_spec = (
13299 
    None, # 0
13300 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13301 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13302 
    (3, TType.I64, 'toDate', None, None, ), # 3
13303 
  )
13304 
 
13305 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13306 
    self.warehouseId = warehouseId
13307 
    self.fromDate = fromDate
13308 
    self.toDate = toDate
13309 
 
13310 
  def read(self, iprot):
13311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13313 
      return
13314 
    iprot.readStructBegin()
13315 
    while True:
13316 
      (fname, ftype, fid) = iprot.readFieldBegin()
13317 
      if ftype == TType.STOP:
13318 
        break
13319 
      if fid == 1:
13320 
        if ftype == TType.I64:
13321 
          self.warehouseId = iprot.readI64();
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      elif fid == 2:
13325 
        if ftype == TType.I64:
13326 
          self.fromDate = iprot.readI64();
13327 
        else:
13328 
          iprot.skip(ftype)
13329 
      elif fid == 3:
13330 
        if ftype == TType.I64:
13331 
          self.toDate = iprot.readI64();
13332 
        else:
13333 
          iprot.skip(ftype)
13334 
      else:
13335 
        iprot.skip(ftype)
13336 
      iprot.readFieldEnd()
13337 
    iprot.readStructEnd()
13338 
 
13339 
  def write(self, oprot):
13340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13342 
      return
13343 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13344 
    if self.warehouseId is not None:
2690 chandransh 13345 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13346 
      oprot.writeI64(self.warehouseId)
13347 
      oprot.writeFieldEnd()
3431 rajveer 13348 
    if self.fromDate is not None:
2690 chandransh 13349 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13350 
      oprot.writeI64(self.fromDate)
13351 
      oprot.writeFieldEnd()
3431 rajveer 13352 
    if self.toDate is not None:
2690 chandransh 13353 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13354 
      oprot.writeI64(self.toDate)
13355 
      oprot.writeFieldEnd()
13356 
    oprot.writeFieldStop()
13357 
    oprot.writeStructEnd()
13358 
 
3431 rajveer 13359 
  def validate(self):
13360 
    return
13361 
 
13362 
 
2690 chandransh 13363 
  def __repr__(self):
13364 
    L = ['%s=%r' % (key, value)
13365 
      for key, value in self.__dict__.iteritems()]
13366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13367 
 
13368 
  def __eq__(self, other):
13369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13370 
 
13371 
  def __ne__(self, other):
13372 
    return not (self == other)
13373 
 
13374 
class getReturnOrders_result:
13375 
  """
13376 
  Attributes:
13377 
   - success
13378 
  """
13379 
 
13380 
  thrift_spec = (
13381 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13382 
  )
13383 
 
13384 
  def __init__(self, success=None,):
13385 
    self.success = success
13386 
 
13387 
  def read(self, iprot):
13388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13390 
      return
13391 
    iprot.readStructBegin()
13392 
    while True:
13393 
      (fname, ftype, fid) = iprot.readFieldBegin()
13394 
      if ftype == TType.STOP:
13395 
        break
13396 
      if fid == 0:
13397 
        if ftype == TType.LIST:
13398 
          self.success = []
4581 phani.kuma 13399 
          (_etype216, _size213) = iprot.readListBegin()
13400 
          for _i217 in xrange(_size213):
13401 
            _elem218 = ReturnOrder()
13402 
            _elem218.read(iprot)
13403 
            self.success.append(_elem218)
2690 chandransh 13404 
          iprot.readListEnd()
13405 
        else:
13406 
          iprot.skip(ftype)
13407 
      else:
13408 
        iprot.skip(ftype)
13409 
      iprot.readFieldEnd()
13410 
    iprot.readStructEnd()
13411 
 
13412 
  def write(self, oprot):
13413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13415 
      return
13416 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13417 
    if self.success is not None:
2690 chandransh 13418 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13419 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13420 
      for iter219 in self.success:
13421 
        iter219.write(oprot)
2690 chandransh 13422 
      oprot.writeListEnd()
13423 
      oprot.writeFieldEnd()
13424 
    oprot.writeFieldStop()
13425 
    oprot.writeStructEnd()
13426 
 
3431 rajveer 13427 
  def validate(self):
13428 
    return
13429 
 
13430 
 
2690 chandransh 13431 
  def __repr__(self):
13432 
    L = ['%s=%r' % (key, value)
13433 
      for key, value in self.__dict__.iteritems()]
13434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13435 
 
13436 
  def __eq__(self, other):
13437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13438 
 
13439 
  def __ne__(self, other):
13440 
    return not (self == other)
13441 
 
2700 chandransh 13442 
class getReturnOrder_args:
13443 
  """
13444 
  Attributes:
13445 
   - id
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    None, # 0
13450 
    (1, TType.I64, 'id', None, None, ), # 1
13451 
  )
13452 
 
13453 
  def __init__(self, id=None,):
13454 
    self.id = id
13455 
 
13456 
  def read(self, iprot):
13457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13459 
      return
13460 
    iprot.readStructBegin()
13461 
    while True:
13462 
      (fname, ftype, fid) = iprot.readFieldBegin()
13463 
      if ftype == TType.STOP:
13464 
        break
13465 
      if fid == 1:
13466 
        if ftype == TType.I64:
13467 
          self.id = iprot.readI64();
13468 
        else:
13469 
          iprot.skip(ftype)
13470 
      else:
13471 
        iprot.skip(ftype)
13472 
      iprot.readFieldEnd()
13473 
    iprot.readStructEnd()
13474 
 
13475 
  def write(self, oprot):
13476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13478 
      return
13479 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13480 
    if self.id is not None:
2700 chandransh 13481 
      oprot.writeFieldBegin('id', TType.I64, 1)
13482 
      oprot.writeI64(self.id)
13483 
      oprot.writeFieldEnd()
13484 
    oprot.writeFieldStop()
13485 
    oprot.writeStructEnd()
13486 
 
3431 rajveer 13487 
  def validate(self):
13488 
    return
13489 
 
13490 
 
2700 chandransh 13491 
  def __repr__(self):
13492 
    L = ['%s=%r' % (key, value)
13493 
      for key, value in self.__dict__.iteritems()]
13494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13495 
 
13496 
  def __eq__(self, other):
13497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13498 
 
13499 
  def __ne__(self, other):
13500 
    return not (self == other)
13501 
 
13502 
class getReturnOrder_result:
13503 
  """
13504 
  Attributes:
13505 
   - success
13506 
   - ex
13507 
  """
13508 
 
13509 
  thrift_spec = (
13510 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13511 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13512 
  )
13513 
 
13514 
  def __init__(self, success=None, ex=None,):
13515 
    self.success = success
13516 
    self.ex = ex
13517 
 
13518 
  def read(self, iprot):
13519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13521 
      return
13522 
    iprot.readStructBegin()
13523 
    while True:
13524 
      (fname, ftype, fid) = iprot.readFieldBegin()
13525 
      if ftype == TType.STOP:
13526 
        break
13527 
      if fid == 0:
13528 
        if ftype == TType.STRUCT:
13529 
          self.success = ReturnOrder()
13530 
          self.success.read(iprot)
13531 
        else:
13532 
          iprot.skip(ftype)
13533 
      elif fid == 1:
13534 
        if ftype == TType.STRUCT:
13535 
          self.ex = TransactionServiceException()
13536 
          self.ex.read(iprot)
13537 
        else:
13538 
          iprot.skip(ftype)
13539 
      else:
13540 
        iprot.skip(ftype)
13541 
      iprot.readFieldEnd()
13542 
    iprot.readStructEnd()
13543 
 
13544 
  def write(self, oprot):
13545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13547 
      return
13548 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13549 
    if self.success is not None:
2700 chandransh 13550 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13551 
      self.success.write(oprot)
13552 
      oprot.writeFieldEnd()
3431 rajveer 13553 
    if self.ex is not None:
2700 chandransh 13554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13555 
      self.ex.write(oprot)
13556 
      oprot.writeFieldEnd()
13557 
    oprot.writeFieldStop()
13558 
    oprot.writeStructEnd()
13559 
 
3431 rajveer 13560 
  def validate(self):
13561 
    return
13562 
 
13563 
 
2700 chandransh 13564 
  def __repr__(self):
13565 
    L = ['%s=%r' % (key, value)
13566 
      for key, value in self.__dict__.iteritems()]
13567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13568 
 
13569 
  def __eq__(self, other):
13570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13571 
 
13572 
  def __ne__(self, other):
13573 
    return not (self == other)
13574 
 
2690 chandransh 13575 
class processReturn_args:
13576 
  """
13577 
  Attributes:
13578 
   - returnOrderId
13579 
  """
13580 
 
13581 
  thrift_spec = (
13582 
    None, # 0
13583 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13584 
  )
13585 
 
13586 
  def __init__(self, returnOrderId=None,):
13587 
    self.returnOrderId = returnOrderId
13588 
 
13589 
  def read(self, iprot):
13590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13592 
      return
13593 
    iprot.readStructBegin()
13594 
    while True:
13595 
      (fname, ftype, fid) = iprot.readFieldBegin()
13596 
      if ftype == TType.STOP:
13597 
        break
13598 
      if fid == 1:
13599 
        if ftype == TType.I64:
13600 
          self.returnOrderId = iprot.readI64();
13601 
        else:
13602 
          iprot.skip(ftype)
13603 
      else:
13604 
        iprot.skip(ftype)
13605 
      iprot.readFieldEnd()
13606 
    iprot.readStructEnd()
13607 
 
13608 
  def write(self, oprot):
13609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13611 
      return
13612 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13613 
    if self.returnOrderId is not None:
2690 chandransh 13614 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13615 
      oprot.writeI64(self.returnOrderId)
13616 
      oprot.writeFieldEnd()
13617 
    oprot.writeFieldStop()
13618 
    oprot.writeStructEnd()
13619 
 
3431 rajveer 13620 
  def validate(self):
13621 
    return
13622 
 
13623 
 
2690 chandransh 13624 
  def __repr__(self):
13625 
    L = ['%s=%r' % (key, value)
13626 
      for key, value in self.__dict__.iteritems()]
13627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13628 
 
13629 
  def __eq__(self, other):
13630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13631 
 
13632 
  def __ne__(self, other):
13633 
    return not (self == other)
13634 
 
13635 
class processReturn_result:
13636 
  """
13637 
  Attributes:
13638 
   - ex
13639 
  """
13640 
 
13641 
  thrift_spec = (
13642 
    None, # 0
13643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13644 
  )
13645 
 
13646 
  def __init__(self, ex=None,):
13647 
    self.ex = ex
13648 
 
13649 
  def read(self, iprot):
13650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13652 
      return
13653 
    iprot.readStructBegin()
13654 
    while True:
13655 
      (fname, ftype, fid) = iprot.readFieldBegin()
13656 
      if ftype == TType.STOP:
13657 
        break
13658 
      if fid == 1:
13659 
        if ftype == TType.STRUCT:
13660 
          self.ex = TransactionServiceException()
13661 
          self.ex.read(iprot)
13662 
        else:
13663 
          iprot.skip(ftype)
13664 
      else:
13665 
        iprot.skip(ftype)
13666 
      iprot.readFieldEnd()
13667 
    iprot.readStructEnd()
13668 
 
13669 
  def write(self, oprot):
13670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13672 
      return
13673 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13674 
    if self.ex is not None:
2690 chandransh 13675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13676 
      self.ex.write(oprot)
13677 
      oprot.writeFieldEnd()
13678 
    oprot.writeFieldStop()
13679 
    oprot.writeStructEnd()
13680 
 
3431 rajveer 13681 
  def validate(self):
13682 
    return
13683 
 
13684 
 
2690 chandransh 13685 
  def __repr__(self):
13686 
    L = ['%s=%r' % (key, value)
13687 
      for key, value in self.__dict__.iteritems()]
13688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13689 
 
13690 
  def __eq__(self, other):
13691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13692 
 
13693 
  def __ne__(self, other):
13694 
    return not (self == other)
13695 
 
2819 chandransh 13696 
class createPurchaseOrder_args:
13697 
  """
13698 
  Attributes:
13699 
   - warehouseId
13700 
  """
2690 chandransh 13701 
 
2819 chandransh 13702 
  thrift_spec = (
13703 
    None, # 0
13704 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13705 
  )
13706 
 
13707 
  def __init__(self, warehouseId=None,):
13708 
    self.warehouseId = warehouseId
13709 
 
13710 
  def read(self, iprot):
13711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13713 
      return
13714 
    iprot.readStructBegin()
13715 
    while True:
13716 
      (fname, ftype, fid) = iprot.readFieldBegin()
13717 
      if ftype == TType.STOP:
13718 
        break
13719 
      if fid == 1:
13720 
        if ftype == TType.I64:
13721 
          self.warehouseId = iprot.readI64();
13722 
        else:
13723 
          iprot.skip(ftype)
13724 
      else:
13725 
        iprot.skip(ftype)
13726 
      iprot.readFieldEnd()
13727 
    iprot.readStructEnd()
13728 
 
13729 
  def write(self, oprot):
13730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13732 
      return
13733 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13734 
    if self.warehouseId is not None:
2819 chandransh 13735 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13736 
      oprot.writeI64(self.warehouseId)
13737 
      oprot.writeFieldEnd()
13738 
    oprot.writeFieldStop()
13739 
    oprot.writeStructEnd()
13740 
 
3431 rajveer 13741 
  def validate(self):
13742 
    return
13743 
 
13744 
 
2819 chandransh 13745 
  def __repr__(self):
13746 
    L = ['%s=%r' % (key, value)
13747 
      for key, value in self.__dict__.iteritems()]
13748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13749 
 
13750 
  def __eq__(self, other):
13751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13752 
 
13753 
  def __ne__(self, other):
13754 
    return not (self == other)
13755 
 
13756 
class createPurchaseOrder_result:
13757 
  """
13758 
  Attributes:
13759 
   - success
13760 
   - ex
13761 
  """
13762 
 
13763 
  thrift_spec = (
4586 mandeep.dh 13764 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13766 
  )
13767 
 
13768 
  def __init__(self, success=None, ex=None,):
13769 
    self.success = success
13770 
    self.ex = ex
13771 
 
13772 
  def read(self, iprot):
13773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13775 
      return
13776 
    iprot.readStructBegin()
13777 
    while True:
13778 
      (fname, ftype, fid) = iprot.readFieldBegin()
13779 
      if ftype == TType.STOP:
13780 
        break
13781 
      if fid == 0:
4586 mandeep.dh 13782 
        if ftype == TType.LIST:
13783 
          self.success = []
13784 
          (_etype223, _size220) = iprot.readListBegin()
13785 
          for _i224 in xrange(_size220):
13786 
            _elem225 = iprot.readI64();
13787 
            self.success.append(_elem225)
13788 
          iprot.readListEnd()
2819 chandransh 13789 
        else:
13790 
          iprot.skip(ftype)
13791 
      elif fid == 1:
13792 
        if ftype == TType.STRUCT:
13793 
          self.ex = TransactionServiceException()
13794 
          self.ex.read(iprot)
13795 
        else:
13796 
          iprot.skip(ftype)
13797 
      else:
13798 
        iprot.skip(ftype)
13799 
      iprot.readFieldEnd()
13800 
    iprot.readStructEnd()
13801 
 
13802 
  def write(self, oprot):
13803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13805 
      return
13806 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13807 
    if self.success is not None:
4586 mandeep.dh 13808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13809 
      oprot.writeListBegin(TType.I64, len(self.success))
13810 
      for iter226 in self.success:
13811 
        oprot.writeI64(iter226)
13812 
      oprot.writeListEnd()
2819 chandransh 13813 
      oprot.writeFieldEnd()
3431 rajveer 13814 
    if self.ex is not None:
2819 chandransh 13815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13816 
      self.ex.write(oprot)
13817 
      oprot.writeFieldEnd()
13818 
    oprot.writeFieldStop()
13819 
    oprot.writeStructEnd()
13820 
 
3431 rajveer 13821 
  def validate(self):
13822 
    return
13823 
 
13824 
 
2819 chandransh 13825 
  def __repr__(self):
13826 
    L = ['%s=%r' % (key, value)
13827 
      for key, value in self.__dict__.iteritems()]
13828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13829 
 
13830 
  def __eq__(self, other):
13831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13832 
 
13833 
  def __ne__(self, other):
13834 
    return not (self == other)
3451 chandransh 13835 
 
13836 
class updateWeight_args:
13837 
  """
13838 
  Attributes:
13839 
   - orderId
13840 
   - weight
13841 
  """
13842 
 
13843 
  thrift_spec = (
13844 
    None, # 0
13845 
    (1, TType.I64, 'orderId', None, None, ), # 1
13846 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13847 
  )
13848 
 
13849 
  def __init__(self, orderId=None, weight=None,):
13850 
    self.orderId = orderId
13851 
    self.weight = weight
13852 
 
13853 
  def read(self, iprot):
13854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13856 
      return
13857 
    iprot.readStructBegin()
13858 
    while True:
13859 
      (fname, ftype, fid) = iprot.readFieldBegin()
13860 
      if ftype == TType.STOP:
13861 
        break
13862 
      if fid == 1:
13863 
        if ftype == TType.I64:
13864 
          self.orderId = iprot.readI64();
13865 
        else:
13866 
          iprot.skip(ftype)
13867 
      elif fid == 2:
13868 
        if ftype == TType.DOUBLE:
13869 
          self.weight = iprot.readDouble();
13870 
        else:
13871 
          iprot.skip(ftype)
13872 
      else:
13873 
        iprot.skip(ftype)
13874 
      iprot.readFieldEnd()
13875 
    iprot.readStructEnd()
13876 
 
13877 
  def write(self, oprot):
13878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13880 
      return
13881 
    oprot.writeStructBegin('updateWeight_args')
13882 
    if self.orderId is not None:
13883 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13884 
      oprot.writeI64(self.orderId)
13885 
      oprot.writeFieldEnd()
13886 
    if self.weight is not None:
13887 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13888 
      oprot.writeDouble(self.weight)
13889 
      oprot.writeFieldEnd()
13890 
    oprot.writeFieldStop()
13891 
    oprot.writeStructEnd()
13892 
 
13893 
  def validate(self):
13894 
    return
13895 
 
13896 
 
13897 
  def __repr__(self):
13898 
    L = ['%s=%r' % (key, value)
13899 
      for key, value in self.__dict__.iteritems()]
13900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13901 
 
13902 
  def __eq__(self, other):
13903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13904 
 
13905 
  def __ne__(self, other):
13906 
    return not (self == other)
13907 
 
13908 
class updateWeight_result:
13909 
  """
13910 
  Attributes:
13911 
   - success
13912 
   - ex
13913 
  """
13914 
 
13915 
  thrift_spec = (
13916 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13918 
  )
13919 
 
13920 
  def __init__(self, success=None, ex=None,):
13921 
    self.success = success
13922 
    self.ex = ex
13923 
 
13924 
  def read(self, iprot):
13925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13927 
      return
13928 
    iprot.readStructBegin()
13929 
    while True:
13930 
      (fname, ftype, fid) = iprot.readFieldBegin()
13931 
      if ftype == TType.STOP:
13932 
        break
13933 
      if fid == 0:
13934 
        if ftype == TType.STRUCT:
13935 
          self.success = Order()
13936 
          self.success.read(iprot)
13937 
        else:
13938 
          iprot.skip(ftype)
13939 
      elif fid == 1:
13940 
        if ftype == TType.STRUCT:
13941 
          self.ex = TransactionServiceException()
13942 
          self.ex.read(iprot)
13943 
        else:
13944 
          iprot.skip(ftype)
13945 
      else:
13946 
        iprot.skip(ftype)
13947 
      iprot.readFieldEnd()
13948 
    iprot.readStructEnd()
13949 
 
13950 
  def write(self, oprot):
13951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13953 
      return
13954 
    oprot.writeStructBegin('updateWeight_result')
13955 
    if self.success is not None:
13956 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13957 
      self.success.write(oprot)
13958 
      oprot.writeFieldEnd()
13959 
    if self.ex is not None:
13960 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13961 
      self.ex.write(oprot)
13962 
      oprot.writeFieldEnd()
13963 
    oprot.writeFieldStop()
13964 
    oprot.writeStructEnd()
13965 
 
13966 
  def validate(self):
13967 
    return
13968 
 
13969 
 
13970 
  def __repr__(self):
13971 
    L = ['%s=%r' % (key, value)
13972 
      for key, value in self.__dict__.iteritems()]
13973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13974 
 
13975 
  def __eq__(self, other):
13976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13977 
 
13978 
  def __ne__(self, other):
13979 
    return not (self == other)
3469 chandransh 13980 
 
13981 
class changeItem_args:
13982 
  """
13983 
  Attributes:
13984 
   - orderId
13985 
   - itemId
13986 
  """
13987 
 
13988 
  thrift_spec = (
13989 
    None, # 0
13990 
    (1, TType.I64, 'orderId', None, None, ), # 1
13991 
    (2, TType.I64, 'itemId', None, None, ), # 2
13992 
  )
13993 
 
13994 
  def __init__(self, orderId=None, itemId=None,):
13995 
    self.orderId = orderId
13996 
    self.itemId = itemId
13997 
 
13998 
  def read(self, iprot):
13999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14001 
      return
14002 
    iprot.readStructBegin()
14003 
    while True:
14004 
      (fname, ftype, fid) = iprot.readFieldBegin()
14005 
      if ftype == TType.STOP:
14006 
        break
14007 
      if fid == 1:
14008 
        if ftype == TType.I64:
14009 
          self.orderId = iprot.readI64();
14010 
        else:
14011 
          iprot.skip(ftype)
14012 
      elif fid == 2:
14013 
        if ftype == TType.I64:
14014 
          self.itemId = iprot.readI64();
14015 
        else:
14016 
          iprot.skip(ftype)
14017 
      else:
14018 
        iprot.skip(ftype)
14019 
      iprot.readFieldEnd()
14020 
    iprot.readStructEnd()
14021 
 
14022 
  def write(self, oprot):
14023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14025 
      return
14026 
    oprot.writeStructBegin('changeItem_args')
14027 
    if self.orderId is not None:
14028 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14029 
      oprot.writeI64(self.orderId)
14030 
      oprot.writeFieldEnd()
14031 
    if self.itemId is not None:
14032 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14033 
      oprot.writeI64(self.itemId)
14034 
      oprot.writeFieldEnd()
14035 
    oprot.writeFieldStop()
14036 
    oprot.writeStructEnd()
14037 
 
14038 
  def validate(self):
14039 
    return
14040 
 
14041 
 
14042 
  def __repr__(self):
14043 
    L = ['%s=%r' % (key, value)
14044 
      for key, value in self.__dict__.iteritems()]
14045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14046 
 
14047 
  def __eq__(self, other):
14048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14049 
 
14050 
  def __ne__(self, other):
14051 
    return not (self == other)
14052 
 
14053 
class changeItem_result:
14054 
  """
14055 
  Attributes:
14056 
   - success
14057 
   - ex
14058 
  """
14059 
 
14060 
  thrift_spec = (
14061 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14063 
  )
14064 
 
14065 
  def __init__(self, success=None, ex=None,):
14066 
    self.success = success
14067 
    self.ex = ex
14068 
 
14069 
  def read(self, iprot):
14070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14072 
      return
14073 
    iprot.readStructBegin()
14074 
    while True:
14075 
      (fname, ftype, fid) = iprot.readFieldBegin()
14076 
      if ftype == TType.STOP:
14077 
        break
14078 
      if fid == 0:
14079 
        if ftype == TType.STRUCT:
14080 
          self.success = Order()
14081 
          self.success.read(iprot)
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      elif fid == 1:
14085 
        if ftype == TType.STRUCT:
14086 
          self.ex = TransactionServiceException()
14087 
          self.ex.read(iprot)
14088 
        else:
14089 
          iprot.skip(ftype)
14090 
      else:
14091 
        iprot.skip(ftype)
14092 
      iprot.readFieldEnd()
14093 
    iprot.readStructEnd()
14094 
 
14095 
  def write(self, oprot):
14096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14098 
      return
14099 
    oprot.writeStructBegin('changeItem_result')
14100 
    if self.success is not None:
14101 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14102 
      self.success.write(oprot)
14103 
      oprot.writeFieldEnd()
14104 
    if self.ex is not None:
14105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14106 
      self.ex.write(oprot)
14107 
      oprot.writeFieldEnd()
14108 
    oprot.writeFieldStop()
14109 
    oprot.writeStructEnd()
14110 
 
14111 
  def validate(self):
14112 
    return
14113 
 
14114 
 
14115 
  def __repr__(self):
14116 
    L = ['%s=%r' % (key, value)
14117 
      for key, value in self.__dict__.iteritems()]
14118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14119 
 
14120 
  def __eq__(self, other):
14121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14122 
 
14123 
  def __ne__(self, other):
14124 
    return not (self == other)
14125 
 
14126 
class shiftToWarehouse_args:
14127 
  """
14128 
  Attributes:
14129 
   - orderId
14130 
   - warehouseId
14131 
  """
14132 
 
14133 
  thrift_spec = (
14134 
    None, # 0
14135 
    (1, TType.I64, 'orderId', None, None, ), # 1
14136 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14137 
  )
14138 
 
14139 
  def __init__(self, orderId=None, warehouseId=None,):
14140 
    self.orderId = orderId
14141 
    self.warehouseId = warehouseId
14142 
 
14143 
  def read(self, iprot):
14144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14146 
      return
14147 
    iprot.readStructBegin()
14148 
    while True:
14149 
      (fname, ftype, fid) = iprot.readFieldBegin()
14150 
      if ftype == TType.STOP:
14151 
        break
14152 
      if fid == 1:
14153 
        if ftype == TType.I64:
14154 
          self.orderId = iprot.readI64();
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      elif fid == 2:
14158 
        if ftype == TType.I64:
14159 
          self.warehouseId = iprot.readI64();
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      else:
14163 
        iprot.skip(ftype)
14164 
      iprot.readFieldEnd()
14165 
    iprot.readStructEnd()
14166 
 
14167 
  def write(self, oprot):
14168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14170 
      return
14171 
    oprot.writeStructBegin('shiftToWarehouse_args')
14172 
    if self.orderId is not None:
14173 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14174 
      oprot.writeI64(self.orderId)
14175 
      oprot.writeFieldEnd()
14176 
    if self.warehouseId is not None:
14177 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14178 
      oprot.writeI64(self.warehouseId)
14179 
      oprot.writeFieldEnd()
14180 
    oprot.writeFieldStop()
14181 
    oprot.writeStructEnd()
14182 
 
14183 
  def validate(self):
14184 
    return
14185 
 
14186 
 
14187 
  def __repr__(self):
14188 
    L = ['%s=%r' % (key, value)
14189 
      for key, value in self.__dict__.iteritems()]
14190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14191 
 
14192 
  def __eq__(self, other):
14193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14194 
 
14195 
  def __ne__(self, other):
14196 
    return not (self == other)
14197 
 
14198 
class shiftToWarehouse_result:
14199 
  """
14200 
  Attributes:
14201 
   - success
14202 
   - ex
14203 
  """
14204 
 
14205 
  thrift_spec = (
14206 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14207 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14208 
  )
14209 
 
14210 
  def __init__(self, success=None, ex=None,):
14211 
    self.success = success
14212 
    self.ex = ex
14213 
 
14214 
  def read(self, iprot):
14215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14217 
      return
14218 
    iprot.readStructBegin()
14219 
    while True:
14220 
      (fname, ftype, fid) = iprot.readFieldBegin()
14221 
      if ftype == TType.STOP:
14222 
        break
14223 
      if fid == 0:
14224 
        if ftype == TType.STRUCT:
14225 
          self.success = Order()
14226 
          self.success.read(iprot)
14227 
        else:
14228 
          iprot.skip(ftype)
14229 
      elif fid == 1:
14230 
        if ftype == TType.STRUCT:
14231 
          self.ex = TransactionServiceException()
14232 
          self.ex.read(iprot)
14233 
        else:
14234 
          iprot.skip(ftype)
14235 
      else:
14236 
        iprot.skip(ftype)
14237 
      iprot.readFieldEnd()
14238 
    iprot.readStructEnd()
14239 
 
14240 
  def write(self, oprot):
14241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14243 
      return
14244 
    oprot.writeStructBegin('shiftToWarehouse_result')
14245 
    if self.success is not None:
14246 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14247 
      self.success.write(oprot)
14248 
      oprot.writeFieldEnd()
14249 
    if self.ex is not None:
14250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14251 
      self.ex.write(oprot)
14252 
      oprot.writeFieldEnd()
14253 
    oprot.writeFieldStop()
14254 
    oprot.writeStructEnd()
14255 
 
14256 
  def validate(self):
14257 
    return
14258 
 
14259 
 
14260 
  def __repr__(self):
14261 
    L = ['%s=%r' % (key, value)
14262 
      for key, value in self.__dict__.iteritems()]
14263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14264 
 
14265 
  def __eq__(self, other):
14266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14267 
 
14268 
  def __ne__(self, other):
14269 
    return not (self == other)
3553 chandransh 14270 
 
14271 
class addDelayReason_args:
14272 
  """
14273 
  Attributes:
14274 
   - orderId
14275 
   - delayReason
3986 chandransh 14276 
   - furtherDelay
3553 chandransh 14277 
  """
14278 
 
14279 
  thrift_spec = (
14280 
    None, # 0
14281 
    (1, TType.I64, 'orderId', None, None, ), # 1
14282 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14283 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 14284 
  )
14285 
 
3986 chandransh 14286 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 14287 
    self.orderId = orderId
14288 
    self.delayReason = delayReason
3986 chandransh 14289 
    self.furtherDelay = furtherDelay
3553 chandransh 14290 
 
14291 
  def read(self, iprot):
14292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14294 
      return
14295 
    iprot.readStructBegin()
14296 
    while True:
14297 
      (fname, ftype, fid) = iprot.readFieldBegin()
14298 
      if ftype == TType.STOP:
14299 
        break
14300 
      if fid == 1:
14301 
        if ftype == TType.I64:
14302 
          self.orderId = iprot.readI64();
14303 
        else:
14304 
          iprot.skip(ftype)
14305 
      elif fid == 2:
14306 
        if ftype == TType.I32:
14307 
          self.delayReason = iprot.readI32();
14308 
        else:
14309 
          iprot.skip(ftype)
3986 chandransh 14310 
      elif fid == 3:
14311 
        if ftype == TType.I64:
14312 
          self.furtherDelay = iprot.readI64();
14313 
        else:
14314 
          iprot.skip(ftype)
3553 chandransh 14315 
      else:
14316 
        iprot.skip(ftype)
14317 
      iprot.readFieldEnd()
14318 
    iprot.readStructEnd()
14319 
 
14320 
  def write(self, oprot):
14321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14323 
      return
14324 
    oprot.writeStructBegin('addDelayReason_args')
14325 
    if self.orderId is not None:
14326 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14327 
      oprot.writeI64(self.orderId)
14328 
      oprot.writeFieldEnd()
14329 
    if self.delayReason is not None:
14330 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14331 
      oprot.writeI32(self.delayReason)
14332 
      oprot.writeFieldEnd()
3986 chandransh 14333 
    if self.furtherDelay is not None:
14334 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14335 
      oprot.writeI64(self.furtherDelay)
14336 
      oprot.writeFieldEnd()
3553 chandransh 14337 
    oprot.writeFieldStop()
14338 
    oprot.writeStructEnd()
14339 
 
14340 
  def validate(self):
14341 
    return
14342 
 
14343 
 
14344 
  def __repr__(self):
14345 
    L = ['%s=%r' % (key, value)
14346 
      for key, value in self.__dict__.iteritems()]
14347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14348 
 
14349 
  def __eq__(self, other):
14350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14351 
 
14352 
  def __ne__(self, other):
14353 
    return not (self == other)
14354 
 
14355 
class addDelayReason_result:
14356 
  """
14357 
  Attributes:
14358 
   - success
14359 
   - ex
14360 
  """
14361 
 
14362 
  thrift_spec = (
14363 
    (0, TType.BOOL, 'success', None, None, ), # 0
14364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14365 
  )
14366 
 
14367 
  def __init__(self, success=None, ex=None,):
14368 
    self.success = success
14369 
    self.ex = ex
14370 
 
14371 
  def read(self, iprot):
14372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14374 
      return
14375 
    iprot.readStructBegin()
14376 
    while True:
14377 
      (fname, ftype, fid) = iprot.readFieldBegin()
14378 
      if ftype == TType.STOP:
14379 
        break
14380 
      if fid == 0:
14381 
        if ftype == TType.BOOL:
14382 
          self.success = iprot.readBool();
14383 
        else:
14384 
          iprot.skip(ftype)
14385 
      elif fid == 1:
14386 
        if ftype == TType.STRUCT:
14387 
          self.ex = TransactionServiceException()
14388 
          self.ex.read(iprot)
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      else:
14392 
        iprot.skip(ftype)
14393 
      iprot.readFieldEnd()
14394 
    iprot.readStructEnd()
14395 
 
14396 
  def write(self, oprot):
14397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14399 
      return
14400 
    oprot.writeStructBegin('addDelayReason_result')
14401 
    if self.success is not None:
14402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14403 
      oprot.writeBool(self.success)
14404 
      oprot.writeFieldEnd()
14405 
    if self.ex is not None:
14406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14407 
      self.ex.write(oprot)
14408 
      oprot.writeFieldEnd()
14409 
    oprot.writeFieldStop()
14410 
    oprot.writeStructEnd()
14411 
 
14412 
  def validate(self):
14413 
    return
14414 
 
14415 
 
14416 
  def __repr__(self):
14417 
    L = ['%s=%r' % (key, value)
14418 
      for key, value in self.__dict__.iteritems()]
14419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14420 
 
14421 
  def __eq__(self, other):
14422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14423 
 
14424 
  def __ne__(self, other):
14425 
    return not (self == other)
3956 chandransh 14426 
 
14427 
class reconcileCodCollection_args:
14428 
  """
14429 
  Attributes:
14430 
   - collectedAmountMap
14431 
   - xferBy
14432 
   - xferTxnId
14433 
   - xferDate
14434 
  """
14435 
 
14436 
  thrift_spec = (
14437 
    None, # 0
14438 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14439 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14440 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14441 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14442 
  )
14443 
 
14444 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14445 
    self.collectedAmountMap = collectedAmountMap
14446 
    self.xferBy = xferBy
14447 
    self.xferTxnId = xferTxnId
14448 
    self.xferDate = xferDate
14449 
 
14450 
  def read(self, iprot):
14451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14453 
      return
14454 
    iprot.readStructBegin()
14455 
    while True:
14456 
      (fname, ftype, fid) = iprot.readFieldBegin()
14457 
      if ftype == TType.STOP:
14458 
        break
14459 
      if fid == 1:
14460 
        if ftype == TType.MAP:
14461 
          self.collectedAmountMap = {}
4586 mandeep.dh 14462 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14463 
          for _i231 in xrange(_size227):
14464 
            _key232 = iprot.readString();
14465 
            _val233 = iprot.readDouble();
14466 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14467 
          iprot.readMapEnd()
14468 
        else:
14469 
          iprot.skip(ftype)
14470 
      elif fid == 2:
14471 
        if ftype == TType.STRING:
14472 
          self.xferBy = iprot.readString();
14473 
        else:
14474 
          iprot.skip(ftype)
14475 
      elif fid == 3:
14476 
        if ftype == TType.STRING:
14477 
          self.xferTxnId = iprot.readString();
14478 
        else:
14479 
          iprot.skip(ftype)
14480 
      elif fid == 4:
14481 
        if ftype == TType.I64:
14482 
          self.xferDate = iprot.readI64();
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
14494 
    oprot.writeStructBegin('reconcileCodCollection_args')
14495 
    if self.collectedAmountMap is not None:
14496 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14497 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14498 
      for kiter234,viter235 in self.collectedAmountMap.items():
14499 
        oprot.writeString(kiter234)
14500 
        oprot.writeDouble(viter235)
3956 chandransh 14501 
      oprot.writeMapEnd()
14502 
      oprot.writeFieldEnd()
14503 
    if self.xferBy is not None:
14504 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14505 
      oprot.writeString(self.xferBy)
14506 
      oprot.writeFieldEnd()
14507 
    if self.xferTxnId is not None:
14508 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14509 
      oprot.writeString(self.xferTxnId)
14510 
      oprot.writeFieldEnd()
14511 
    if self.xferDate is not None:
14512 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14513 
      oprot.writeI64(self.xferDate)
14514 
      oprot.writeFieldEnd()
14515 
    oprot.writeFieldStop()
14516 
    oprot.writeStructEnd()
14517 
 
14518 
  def validate(self):
14519 
    return
14520 
 
14521 
 
14522 
  def __repr__(self):
14523 
    L = ['%s=%r' % (key, value)
14524 
      for key, value in self.__dict__.iteritems()]
14525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14526 
 
14527 
  def __eq__(self, other):
14528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14529 
 
14530 
  def __ne__(self, other):
14531 
    return not (self == other)
14532 
 
14533 
class reconcileCodCollection_result:
14534 
  """
14535 
  Attributes:
14536 
   - success
14537 
   - ex
14538 
  """
14539 
 
14540 
  thrift_spec = (
14541 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14543 
  )
14544 
 
14545 
  def __init__(self, success=None, ex=None,):
14546 
    self.success = success
14547 
    self.ex = ex
14548 
 
14549 
  def read(self, iprot):
14550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14552 
      return
14553 
    iprot.readStructBegin()
14554 
    while True:
14555 
      (fname, ftype, fid) = iprot.readFieldBegin()
14556 
      if ftype == TType.STOP:
14557 
        break
14558 
      if fid == 0:
14559 
        if ftype == TType.MAP:
14560 
          self.success = {}
4586 mandeep.dh 14561 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14562 
          for _i240 in xrange(_size236):
14563 
            _key241 = iprot.readString();
14564 
            _val242 = iprot.readString();
14565 
            self.success[_key241] = _val242
3956 chandransh 14566 
          iprot.readMapEnd()
14567 
        else:
14568 
          iprot.skip(ftype)
14569 
      elif fid == 1:
14570 
        if ftype == TType.STRUCT:
14571 
          self.ex = TransactionServiceException()
14572 
          self.ex.read(iprot)
14573 
        else:
14574 
          iprot.skip(ftype)
14575 
      else:
14576 
        iprot.skip(ftype)
14577 
      iprot.readFieldEnd()
14578 
    iprot.readStructEnd()
14579 
 
14580 
  def write(self, oprot):
14581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14583 
      return
14584 
    oprot.writeStructBegin('reconcileCodCollection_result')
14585 
    if self.success is not None:
14586 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14587 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14588 
      for kiter243,viter244 in self.success.items():
14589 
        oprot.writeString(kiter243)
14590 
        oprot.writeString(viter244)
3956 chandransh 14591 
      oprot.writeMapEnd()
14592 
      oprot.writeFieldEnd()
14593 
    if self.ex is not None:
14594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14595 
      self.ex.write(oprot)
14596 
      oprot.writeFieldEnd()
14597 
    oprot.writeFieldStop()
14598 
    oprot.writeStructEnd()
14599 
 
14600 
  def validate(self):
14601 
    return
14602 
 
14603 
 
14604 
  def __repr__(self):
14605 
    L = ['%s=%r' % (key, value)
14606 
      for key, value in self.__dict__.iteritems()]
14607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14608 
 
14609 
  def __eq__(self, other):
14610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14611 
 
14612 
  def __ne__(self, other):
14613 
    return not (self == other)
4008 mandeep.dh 14614 
 
14615 
class getTransactionsRequiringExtraProcessing_args:
14616 
  """
14617 
  Attributes:
14618 
   - category
14619 
  """
14620 
 
14621 
  thrift_spec = (
14622 
    None, # 0
14623 
    (1, TType.I32, 'category', None, None, ), # 1
14624 
  )
14625 
 
14626 
  def __init__(self, category=None,):
14627 
    self.category = category
14628 
 
14629 
  def read(self, iprot):
14630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14632 
      return
14633 
    iprot.readStructBegin()
14634 
    while True:
14635 
      (fname, ftype, fid) = iprot.readFieldBegin()
14636 
      if ftype == TType.STOP:
14637 
        break
14638 
      if fid == 1:
14639 
        if ftype == TType.I32:
14640 
          self.category = iprot.readI32();
14641 
        else:
14642 
          iprot.skip(ftype)
14643 
      else:
14644 
        iprot.skip(ftype)
14645 
      iprot.readFieldEnd()
14646 
    iprot.readStructEnd()
14647 
 
14648 
  def write(self, oprot):
14649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14651 
      return
14652 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14653 
    if self.category is not None:
14654 
      oprot.writeFieldBegin('category', TType.I32, 1)
14655 
      oprot.writeI32(self.category)
14656 
      oprot.writeFieldEnd()
14657 
    oprot.writeFieldStop()
14658 
    oprot.writeStructEnd()
14659 
 
14660 
  def validate(self):
14661 
    return
14662 
 
14663 
 
14664 
  def __repr__(self):
14665 
    L = ['%s=%r' % (key, value)
14666 
      for key, value in self.__dict__.iteritems()]
14667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14668 
 
14669 
  def __eq__(self, other):
14670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14671 
 
14672 
  def __ne__(self, other):
14673 
    return not (self == other)
14674 
 
14675 
class getTransactionsRequiringExtraProcessing_result:
14676 
  """
14677 
  Attributes:
14678 
   - success
14679 
  """
14680 
 
14681 
  thrift_spec = (
14682 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14683 
  )
14684 
 
14685 
  def __init__(self, success=None,):
14686 
    self.success = success
14687 
 
14688 
  def read(self, iprot):
14689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14691 
      return
14692 
    iprot.readStructBegin()
14693 
    while True:
14694 
      (fname, ftype, fid) = iprot.readFieldBegin()
14695 
      if ftype == TType.STOP:
14696 
        break
14697 
      if fid == 0:
14698 
        if ftype == TType.LIST:
14699 
          self.success = []
4586 mandeep.dh 14700 
          (_etype248, _size245) = iprot.readListBegin()
14701 
          for _i249 in xrange(_size245):
14702 
            _elem250 = iprot.readI64();
14703 
            self.success.append(_elem250)
4008 mandeep.dh 14704 
          iprot.readListEnd()
14705 
        else:
14706 
          iprot.skip(ftype)
14707 
      else:
14708 
        iprot.skip(ftype)
14709 
      iprot.readFieldEnd()
14710 
    iprot.readStructEnd()
14711 
 
14712 
  def write(self, oprot):
14713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14715 
      return
14716 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14717 
    if self.success is not None:
14718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14719 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14720 
      for iter251 in self.success:
14721 
        oprot.writeI64(iter251)
4008 mandeep.dh 14722 
      oprot.writeListEnd()
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
14742 
class markTransactionAsProcessed_args:
14743 
  """
14744 
  Attributes:
14745 
   - transactionId
14746 
   - category
14747 
  """
14748 
 
14749 
  thrift_spec = (
14750 
    None, # 0
14751 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14752 
    (2, TType.I32, 'category', None, None, ), # 2
14753 
  )
14754 
 
14755 
  def __init__(self, transactionId=None, category=None,):
14756 
    self.transactionId = transactionId
14757 
    self.category = category
14758 
 
14759 
  def read(self, iprot):
14760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14762 
      return
14763 
    iprot.readStructBegin()
14764 
    while True:
14765 
      (fname, ftype, fid) = iprot.readFieldBegin()
14766 
      if ftype == TType.STOP:
14767 
        break
14768 
      if fid == 1:
14769 
        if ftype == TType.I64:
14770 
          self.transactionId = iprot.readI64();
14771 
        else:
14772 
          iprot.skip(ftype)
14773 
      elif fid == 2:
14774 
        if ftype == TType.I32:
14775 
          self.category = iprot.readI32();
14776 
        else:
14777 
          iprot.skip(ftype)
14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14788 
    if self.transactionId is not None:
14789 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14790 
      oprot.writeI64(self.transactionId)
14791 
      oprot.writeFieldEnd()
14792 
    if self.category is not None:
14793 
      oprot.writeFieldBegin('category', TType.I32, 2)
14794 
      oprot.writeI32(self.category)
14795 
      oprot.writeFieldEnd()
14796 
    oprot.writeFieldStop()
14797 
    oprot.writeStructEnd()
14798 
 
14799 
  def validate(self):
14800 
    return
14801 
 
14802 
 
14803 
  def __repr__(self):
14804 
    L = ['%s=%r' % (key, value)
14805 
      for key, value in self.__dict__.iteritems()]
14806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14807 
 
14808 
  def __eq__(self, other):
14809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14810 
 
14811 
  def __ne__(self, other):
14812 
    return not (self == other)
14813 
 
14814 
class markTransactionAsProcessed_result:
14815 
 
14816 
  thrift_spec = (
14817 
  )
14818 
 
14819 
  def read(self, iprot):
14820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14822 
      return
14823 
    iprot.readStructBegin()
14824 
    while True:
14825 
      (fname, ftype, fid) = iprot.readFieldBegin()
14826 
      if ftype == TType.STOP:
14827 
        break
14828 
      else:
14829 
        iprot.skip(ftype)
14830 
      iprot.readFieldEnd()
14831 
    iprot.readStructEnd()
14832 
 
14833 
  def write(self, oprot):
14834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14836 
      return
14837 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14838 
    oprot.writeFieldStop()
14839 
    oprot.writeStructEnd()
14840 
 
14841 
  def validate(self):
14842 
    return
14843 
 
14844 
 
14845 
  def __repr__(self):
14846 
    L = ['%s=%r' % (key, value)
14847 
      for key, value in self.__dict__.iteritems()]
14848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14849 
 
14850 
  def __eq__(self, other):
14851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14852 
 
14853 
  def __ne__(self, other):
14854 
    return not (self == other)
4018 chandransh 14855 
 
14856 
class getItemWiseRiskyOrdersCount_args:
14857 
 
14858 
  thrift_spec = (
14859 
  )
14860 
 
14861 
  def read(self, iprot):
14862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14864 
      return
14865 
    iprot.readStructBegin()
14866 
    while True:
14867 
      (fname, ftype, fid) = iprot.readFieldBegin()
14868 
      if ftype == TType.STOP:
14869 
        break
14870 
      else:
14871 
        iprot.skip(ftype)
14872 
      iprot.readFieldEnd()
14873 
    iprot.readStructEnd()
14874 
 
14875 
  def write(self, oprot):
14876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14878 
      return
14879 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14880 
    oprot.writeFieldStop()
14881 
    oprot.writeStructEnd()
14882 
 
14883 
  def validate(self):
14884 
    return
14885 
 
14886 
 
14887 
  def __repr__(self):
14888 
    L = ['%s=%r' % (key, value)
14889 
      for key, value in self.__dict__.iteritems()]
14890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14891 
 
14892 
  def __eq__(self, other):
14893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14894 
 
14895 
  def __ne__(self, other):
14896 
    return not (self == other)
14897 
 
14898 
class getItemWiseRiskyOrdersCount_result:
14899 
  """
14900 
  Attributes:
14901 
   - success
14902 
  """
14903 
 
14904 
  thrift_spec = (
14905 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14906 
  )
14907 
 
14908 
  def __init__(self, success=None,):
14909 
    self.success = success
14910 
 
14911 
  def read(self, iprot):
14912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14914 
      return
14915 
    iprot.readStructBegin()
14916 
    while True:
14917 
      (fname, ftype, fid) = iprot.readFieldBegin()
14918 
      if ftype == TType.STOP:
14919 
        break
14920 
      if fid == 0:
14921 
        if ftype == TType.MAP:
14922 
          self.success = {}
4586 mandeep.dh 14923 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
14924 
          for _i256 in xrange(_size252):
14925 
            _key257 = iprot.readI64();
14926 
            _val258 = iprot.readI64();
14927 
            self.success[_key257] = _val258
4018 chandransh 14928 
          iprot.readMapEnd()
14929 
        else:
14930 
          iprot.skip(ftype)
14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
14940 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14941 
    if self.success is not None:
14942 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14943 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 14944 
      for kiter259,viter260 in self.success.items():
14945 
        oprot.writeI64(kiter259)
14946 
        oprot.writeI64(viter260)
4018 chandransh 14947 
      oprot.writeMapEnd()
14948 
      oprot.writeFieldEnd()
14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
4247 rajveer 14966 
 
4295 varun.gupt 14967 
class getOrdersForItemIds_args:
14968 
  """
14969 
  Attributes:
14970 
   - itemIds
14971 
  """
14972 
 
14973 
  thrift_spec = (
14974 
    None, # 0
14975 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14976 
  )
14977 
 
14978 
  def __init__(self, itemIds=None,):
14979 
    self.itemIds = itemIds
14980 
 
14981 
  def read(self, iprot):
14982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14984 
      return
14985 
    iprot.readStructBegin()
14986 
    while True:
14987 
      (fname, ftype, fid) = iprot.readFieldBegin()
14988 
      if ftype == TType.STOP:
14989 
        break
14990 
      if fid == 1:
14991 
        if ftype == TType.LIST:
14992 
          self.itemIds = []
4586 mandeep.dh 14993 
          (_etype264, _size261) = iprot.readListBegin()
14994 
          for _i265 in xrange(_size261):
14995 
            _elem266 = iprot.readI64();
14996 
            self.itemIds.append(_elem266)
4295 varun.gupt 14997 
          iprot.readListEnd()
14998 
        else:
14999 
          iprot.skip(ftype)
15000 
      else:
15001 
        iprot.skip(ftype)
15002 
      iprot.readFieldEnd()
15003 
    iprot.readStructEnd()
15004 
 
15005 
  def write(self, oprot):
15006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15008 
      return
15009 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15010 
    if self.itemIds is not None:
15011 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15012 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15013 
      for iter267 in self.itemIds:
15014 
        oprot.writeI64(iter267)
4295 varun.gupt 15015 
      oprot.writeListEnd()
15016 
      oprot.writeFieldEnd()
15017 
    oprot.writeFieldStop()
15018 
    oprot.writeStructEnd()
15019 
 
15020 
  def validate(self):
15021 
    return
15022 
 
15023 
 
15024 
  def __repr__(self):
15025 
    L = ['%s=%r' % (key, value)
15026 
      for key, value in self.__dict__.iteritems()]
15027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15028 
 
15029 
  def __eq__(self, other):
15030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15031 
 
15032 
  def __ne__(self, other):
15033 
    return not (self == other)
15034 
 
15035 
class getOrdersForItemIds_result:
15036 
  """
15037 
  Attributes:
15038 
   - success
15039 
  """
15040 
 
15041 
  thrift_spec = (
15042 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15043 
  )
15044 
 
15045 
  def __init__(self, success=None,):
15046 
    self.success = success
15047 
 
15048 
  def read(self, iprot):
15049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15051 
      return
15052 
    iprot.readStructBegin()
15053 
    while True:
15054 
      (fname, ftype, fid) = iprot.readFieldBegin()
15055 
      if ftype == TType.STOP:
15056 
        break
15057 
      if fid == 0:
15058 
        if ftype == TType.LIST:
15059 
          self.success = []
4586 mandeep.dh 15060 
          (_etype271, _size268) = iprot.readListBegin()
15061 
          for _i272 in xrange(_size268):
15062 
            _elem273 = Order()
15063 
            _elem273.read(iprot)
15064 
            self.success.append(_elem273)
4295 varun.gupt 15065 
          iprot.readListEnd()
15066 
        else:
15067 
          iprot.skip(ftype)
15068 
      else:
15069 
        iprot.skip(ftype)
15070 
      iprot.readFieldEnd()
15071 
    iprot.readStructEnd()
15072 
 
15073 
  def write(self, oprot):
15074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15076 
      return
15077 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15078 
    if self.success is not None:
15079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15080 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15081 
      for iter274 in self.success:
15082 
        iter274.write(oprot)
4295 varun.gupt 15083 
      oprot.writeListEnd()
15084 
      oprot.writeFieldEnd()
15085 
    oprot.writeFieldStop()
15086 
    oprot.writeStructEnd()
15087 
 
15088 
  def validate(self):
15089 
    return
15090 
 
15091 
 
15092 
  def __repr__(self):
15093 
    L = ['%s=%r' % (key, value)
15094 
      for key, value in self.__dict__.iteritems()]
15095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15096 
 
15097 
  def __eq__(self, other):
15098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15099 
 
15100 
  def __ne__(self, other):
15101 
    return not (self == other)
15102 
 
4247 rajveer 15103 
class markOrderCancellationRequestReceived_args:
15104 
  """
15105 
  Attributes:
15106 
   - orderId
15107 
  """
15108 
 
15109 
  thrift_spec = (
15110 
    None, # 0
15111 
    (1, TType.I64, 'orderId', None, None, ), # 1
15112 
  )
15113 
 
15114 
  def __init__(self, orderId=None,):
15115 
    self.orderId = orderId
15116 
 
15117 
  def read(self, iprot):
15118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15120 
      return
15121 
    iprot.readStructBegin()
15122 
    while True:
15123 
      (fname, ftype, fid) = iprot.readFieldBegin()
15124 
      if ftype == TType.STOP:
15125 
        break
15126 
      if fid == 1:
15127 
        if ftype == TType.I64:
15128 
          self.orderId = iprot.readI64();
15129 
        else:
15130 
          iprot.skip(ftype)
15131 
      else:
15132 
        iprot.skip(ftype)
15133 
      iprot.readFieldEnd()
15134 
    iprot.readStructEnd()
15135 
 
15136 
  def write(self, oprot):
15137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15139 
      return
15140 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15141 
    if self.orderId is not None:
15142 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15143 
      oprot.writeI64(self.orderId)
15144 
      oprot.writeFieldEnd()
15145 
    oprot.writeFieldStop()
15146 
    oprot.writeStructEnd()
15147 
 
15148 
  def validate(self):
15149 
    return
15150 
 
15151 
 
15152 
  def __repr__(self):
15153 
    L = ['%s=%r' % (key, value)
15154 
      for key, value in self.__dict__.iteritems()]
15155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15156 
 
15157 
  def __eq__(self, other):
15158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15159 
 
15160 
  def __ne__(self, other):
15161 
    return not (self == other)
15162 
 
15163 
class markOrderCancellationRequestReceived_result:
15164 
  """
15165 
  Attributes:
15166 
   - ex
15167 
  """
15168 
 
15169 
  thrift_spec = (
15170 
    None, # 0
15171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15172 
  )
15173 
 
15174 
  def __init__(self, ex=None,):
15175 
    self.ex = ex
15176 
 
15177 
  def read(self, iprot):
15178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15180 
      return
15181 
    iprot.readStructBegin()
15182 
    while True:
15183 
      (fname, ftype, fid) = iprot.readFieldBegin()
15184 
      if ftype == TType.STOP:
15185 
        break
15186 
      if fid == 1:
15187 
        if ftype == TType.STRUCT:
15188 
          self.ex = TransactionServiceException()
15189 
          self.ex.read(iprot)
15190 
        else:
15191 
          iprot.skip(ftype)
15192 
      else:
15193 
        iprot.skip(ftype)
15194 
      iprot.readFieldEnd()
15195 
    iprot.readStructEnd()
15196 
 
15197 
  def write(self, oprot):
15198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15200 
      return
15201 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15202 
    if self.ex is not None:
15203 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15204 
      self.ex.write(oprot)
15205 
      oprot.writeFieldEnd()
15206 
    oprot.writeFieldStop()
15207 
    oprot.writeStructEnd()
15208 
 
15209 
  def validate(self):
15210 
    return
15211 
 
15212 
 
15213 
  def __repr__(self):
15214 
    L = ['%s=%r' % (key, value)
15215 
      for key, value in self.__dict__.iteritems()]
15216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15217 
 
15218 
  def __eq__(self, other):
15219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15220 
 
15221 
  def __ne__(self, other):
15222 
    return not (self == other)
15223 
 
15224 
class markOrderCancellationRequestConfirmed_args:
15225 
  """
15226 
  Attributes:
15227 
   - orderId
15228 
  """
15229 
 
15230 
  thrift_spec = (
15231 
    None, # 0
15232 
    (1, TType.I64, 'orderId', None, None, ), # 1
15233 
  )
15234 
 
15235 
  def __init__(self, orderId=None,):
15236 
    self.orderId = orderId
15237 
 
15238 
  def read(self, iprot):
15239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15241 
      return
15242 
    iprot.readStructBegin()
15243 
    while True:
15244 
      (fname, ftype, fid) = iprot.readFieldBegin()
15245 
      if ftype == TType.STOP:
15246 
        break
15247 
      if fid == 1:
15248 
        if ftype == TType.I64:
15249 
          self.orderId = iprot.readI64();
15250 
        else:
15251 
          iprot.skip(ftype)
15252 
      else:
15253 
        iprot.skip(ftype)
15254 
      iprot.readFieldEnd()
15255 
    iprot.readStructEnd()
15256 
 
15257 
  def write(self, oprot):
15258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15260 
      return
15261 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15262 
    if self.orderId is not None:
15263 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15264 
      oprot.writeI64(self.orderId)
15265 
      oprot.writeFieldEnd()
15266 
    oprot.writeFieldStop()
15267 
    oprot.writeStructEnd()
15268 
 
15269 
  def validate(self):
15270 
    return
15271 
 
15272 
 
15273 
  def __repr__(self):
15274 
    L = ['%s=%r' % (key, value)
15275 
      for key, value in self.__dict__.iteritems()]
15276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15277 
 
15278 
  def __eq__(self, other):
15279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15280 
 
15281 
  def __ne__(self, other):
15282 
    return not (self == other)
15283 
 
15284 
class markOrderCancellationRequestConfirmed_result:
15285 
  """
15286 
  Attributes:
15287 
   - ex
15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    None, # 0
15292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15293 
  )
15294 
 
15295 
  def __init__(self, ex=None,):
15296 
    self.ex = ex
15297 
 
15298 
  def read(self, iprot):
15299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15301 
      return
15302 
    iprot.readStructBegin()
15303 
    while True:
15304 
      (fname, ftype, fid) = iprot.readFieldBegin()
15305 
      if ftype == TType.STOP:
15306 
        break
15307 
      if fid == 1:
15308 
        if ftype == TType.STRUCT:
15309 
          self.ex = TransactionServiceException()
15310 
          self.ex.read(iprot)
15311 
        else:
15312 
          iprot.skip(ftype)
15313 
      else:
15314 
        iprot.skip(ftype)
15315 
      iprot.readFieldEnd()
15316 
    iprot.readStructEnd()
15317 
 
15318 
  def write(self, oprot):
15319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15321 
      return
15322 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15323 
    if self.ex is not None:
15324 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15325 
      self.ex.write(oprot)
15326 
      oprot.writeFieldEnd()
15327 
    oprot.writeFieldStop()
15328 
    oprot.writeStructEnd()
15329 
 
15330 
  def validate(self):
15331 
    return
15332 
 
15333 
 
15334 
  def __repr__(self):
15335 
    L = ['%s=%r' % (key, value)
15336 
      for key, value in self.__dict__.iteritems()]
15337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15338 
 
15339 
  def __eq__(self, other):
15340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15341 
 
15342 
  def __ne__(self, other):
15343 
    return not (self == other)
15344 
 
15345 
class markOrderCancellationRequestDenied_args:
15346 
  """
15347 
  Attributes:
15348 
   - orderId
15349 
  """
15350 
 
15351 
  thrift_spec = (
15352 
    None, # 0
15353 
    (1, TType.I64, 'orderId', None, None, ), # 1
15354 
  )
15355 
 
15356 
  def __init__(self, orderId=None,):
15357 
    self.orderId = orderId
15358 
 
15359 
  def read(self, iprot):
15360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15362 
      return
15363 
    iprot.readStructBegin()
15364 
    while True:
15365 
      (fname, ftype, fid) = iprot.readFieldBegin()
15366 
      if ftype == TType.STOP:
15367 
        break
15368 
      if fid == 1:
15369 
        if ftype == TType.I64:
15370 
          self.orderId = iprot.readI64();
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      else:
15374 
        iprot.skip(ftype)
15375 
      iprot.readFieldEnd()
15376 
    iprot.readStructEnd()
15377 
 
15378 
  def write(self, oprot):
15379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15381 
      return
15382 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15383 
    if self.orderId is not None:
15384 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15385 
      oprot.writeI64(self.orderId)
15386 
      oprot.writeFieldEnd()
15387 
    oprot.writeFieldStop()
15388 
    oprot.writeStructEnd()
15389 
 
15390 
  def validate(self):
15391 
    return
15392 
 
15393 
 
15394 
  def __repr__(self):
15395 
    L = ['%s=%r' % (key, value)
15396 
      for key, value in self.__dict__.iteritems()]
15397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15398 
 
15399 
  def __eq__(self, other):
15400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15401 
 
15402 
  def __ne__(self, other):
15403 
    return not (self == other)
15404 
 
15405 
class markOrderCancellationRequestDenied_result:
15406 
  """
15407 
  Attributes:
15408 
   - ex
15409 
  """
15410 
 
15411 
  thrift_spec = (
15412 
    None, # 0
15413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15414 
  )
15415 
 
15416 
  def __init__(self, ex=None,):
15417 
    self.ex = ex
15418 
 
15419 
  def read(self, iprot):
15420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15422 
      return
15423 
    iprot.readStructBegin()
15424 
    while True:
15425 
      (fname, ftype, fid) = iprot.readFieldBegin()
15426 
      if ftype == TType.STOP:
15427 
        break
15428 
      if fid == 1:
15429 
        if ftype == TType.STRUCT:
15430 
          self.ex = TransactionServiceException()
15431 
          self.ex.read(iprot)
15432 
        else:
15433 
          iprot.skip(ftype)
15434 
      else:
15435 
        iprot.skip(ftype)
15436 
      iprot.readFieldEnd()
15437 
    iprot.readStructEnd()
15438 
 
15439 
  def write(self, oprot):
15440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15442 
      return
15443 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15444 
    if self.ex is not None:
15445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15446 
      self.ex.write(oprot)
15447 
      oprot.writeFieldEnd()
15448 
    oprot.writeFieldStop()
15449 
    oprot.writeStructEnd()
15450 
 
15451 
  def validate(self):
15452 
    return
15453 
 
15454 
 
15455 
  def __repr__(self):
15456 
    L = ['%s=%r' % (key, value)
15457 
      for key, value in self.__dict__.iteritems()]
15458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15459 
 
15460 
  def __eq__(self, other):
15461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15462 
 
15463 
  def __ne__(self, other):
15464 
    return not (self == other)
15465 
 
4258 rajveer 15466 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15467 
  """
15468 
  Attributes:
4258 rajveer 15469 
   - transactionId
4247 rajveer 15470 
  """
15471 
 
15472 
  thrift_spec = (
15473 
    None, # 0
4258 rajveer 15474 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15475 
  )
15476 
 
4258 rajveer 15477 
  def __init__(self, transactionId=None,):
15478 
    self.transactionId = transactionId
4247 rajveer 15479 
 
15480 
  def read(self, iprot):
15481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15483 
      return
15484 
    iprot.readStructBegin()
15485 
    while True:
15486 
      (fname, ftype, fid) = iprot.readFieldBegin()
15487 
      if ftype == TType.STOP:
15488 
        break
15489 
      if fid == 1:
15490 
        if ftype == TType.I64:
4258 rajveer 15491 
          self.transactionId = iprot.readI64();
4247 rajveer 15492 
        else:
15493 
          iprot.skip(ftype)
15494 
      else:
15495 
        iprot.skip(ftype)
15496 
      iprot.readFieldEnd()
15497 
    iprot.readStructEnd()
15498 
 
15499 
  def write(self, oprot):
15500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15502 
      return
4258 rajveer 15503 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15504 
    if self.transactionId is not None:
15505 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15506 
      oprot.writeI64(self.transactionId)
4247 rajveer 15507 
      oprot.writeFieldEnd()
15508 
    oprot.writeFieldStop()
15509 
    oprot.writeStructEnd()
15510 
 
15511 
  def validate(self):
15512 
    return
15513 
 
15514 
 
15515 
  def __repr__(self):
15516 
    L = ['%s=%r' % (key, value)
15517 
      for key, value in self.__dict__.iteritems()]
15518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15519 
 
15520 
  def __eq__(self, other):
15521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15522 
 
15523 
  def __ne__(self, other):
15524 
    return not (self == other)
15525 
 
4258 rajveer 15526 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15527 
  """
15528 
  Attributes:
15529 
   - ex
15530 
  """
15531 
 
15532 
  thrift_spec = (
15533 
    None, # 0
15534 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15535 
  )
15536 
 
15537 
  def __init__(self, ex=None,):
15538 
    self.ex = ex
15539 
 
15540 
  def read(self, iprot):
15541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15543 
      return
15544 
    iprot.readStructBegin()
15545 
    while True:
15546 
      (fname, ftype, fid) = iprot.readFieldBegin()
15547 
      if ftype == TType.STOP:
15548 
        break
15549 
      if fid == 1:
15550 
        if ftype == TType.STRUCT:
15551 
          self.ex = TransactionServiceException()
15552 
          self.ex.read(iprot)
15553 
        else:
15554 
          iprot.skip(ftype)
15555 
      else:
15556 
        iprot.skip(ftype)
15557 
      iprot.readFieldEnd()
15558 
    iprot.readStructEnd()
15559 
 
15560 
  def write(self, oprot):
15561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15563 
      return
4258 rajveer 15564 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15565 
    if self.ex is not None:
15566 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15567 
      self.ex.write(oprot)
15568 
      oprot.writeFieldEnd()
15569 
    oprot.writeFieldStop()
15570 
    oprot.writeStructEnd()
15571 
 
15572 
  def validate(self):
15573 
    return
15574 
 
15575 
 
15576 
  def __repr__(self):
15577 
    L = ['%s=%r' % (key, value)
15578 
      for key, value in self.__dict__.iteritems()]
15579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15580 
 
15581 
  def __eq__(self, other):
15582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15583 
 
15584 
  def __ne__(self, other):
15585 
    return not (self == other)
4259 anupam.sin 15586 
 
15587 
class refundTransaction_args:
15588 
  """
15589 
  Attributes:
15590 
   - transactionId
15591 
   - refundedBy
15592 
   - reason
15593 
  """
15594 
 
15595 
  thrift_spec = (
15596 
    None, # 0
15597 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15598 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15599 
    (3, TType.STRING, 'reason', None, None, ), # 3
15600 
  )
15601 
 
15602 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15603 
    self.transactionId = transactionId
15604 
    self.refundedBy = refundedBy
15605 
    self.reason = reason
15606 
 
15607 
  def read(self, iprot):
15608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15610 
      return
15611 
    iprot.readStructBegin()
15612 
    while True:
15613 
      (fname, ftype, fid) = iprot.readFieldBegin()
15614 
      if ftype == TType.STOP:
15615 
        break
15616 
      if fid == 1:
15617 
        if ftype == TType.I64:
15618 
          self.transactionId = iprot.readI64();
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      elif fid == 2:
15622 
        if ftype == TType.STRING:
15623 
          self.refundedBy = iprot.readString();
15624 
        else:
15625 
          iprot.skip(ftype)
15626 
      elif fid == 3:
15627 
        if ftype == TType.STRING:
15628 
          self.reason = iprot.readString();
15629 
        else:
15630 
          iprot.skip(ftype)
15631 
      else:
15632 
        iprot.skip(ftype)
15633 
      iprot.readFieldEnd()
15634 
    iprot.readStructEnd()
15635 
 
15636 
  def write(self, oprot):
15637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15639 
      return
15640 
    oprot.writeStructBegin('refundTransaction_args')
15641 
    if self.transactionId is not None:
15642 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15643 
      oprot.writeI64(self.transactionId)
15644 
      oprot.writeFieldEnd()
15645 
    if self.refundedBy is not None:
15646 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15647 
      oprot.writeString(self.refundedBy)
15648 
      oprot.writeFieldEnd()
15649 
    if self.reason is not None:
15650 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15651 
      oprot.writeString(self.reason)
15652 
      oprot.writeFieldEnd()
15653 
    oprot.writeFieldStop()
15654 
    oprot.writeStructEnd()
15655 
 
15656 
  def validate(self):
15657 
    return
15658 
 
15659 
 
15660 
  def __repr__(self):
15661 
    L = ['%s=%r' % (key, value)
15662 
      for key, value in self.__dict__.iteritems()]
15663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15664 
 
15665 
  def __eq__(self, other):
15666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15667 
 
15668 
  def __ne__(self, other):
15669 
    return not (self == other)
15670 
 
15671 
class refundTransaction_result:
15672 
  """
15673 
  Attributes:
15674 
   - ex
15675 
  """
15676 
 
15677 
  thrift_spec = (
15678 
    None, # 0
15679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15680 
  )
15681 
 
15682 
  def __init__(self, ex=None,):
15683 
    self.ex = ex
15684 
 
15685 
  def read(self, iprot):
15686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15688 
      return
15689 
    iprot.readStructBegin()
15690 
    while True:
15691 
      (fname, ftype, fid) = iprot.readFieldBegin()
15692 
      if ftype == TType.STOP:
15693 
        break
15694 
      if fid == 1:
15695 
        if ftype == TType.STRUCT:
15696 
          self.ex = TransactionServiceException()
15697 
          self.ex.read(iprot)
15698 
        else:
15699 
          iprot.skip(ftype)
15700 
      else:
15701 
        iprot.skip(ftype)
15702 
      iprot.readFieldEnd()
15703 
    iprot.readStructEnd()
15704 
 
15705 
  def write(self, oprot):
15706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15708 
      return
15709 
    oprot.writeStructBegin('refundTransaction_result')
15710 
    if self.ex is not None:
15711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15712 
      self.ex.write(oprot)
15713 
      oprot.writeFieldEnd()
15714 
    oprot.writeFieldStop()
15715 
    oprot.writeStructEnd()
15716 
 
15717 
  def validate(self):
15718 
    return
15719 
 
15720 
 
15721 
  def __repr__(self):
15722 
    L = ['%s=%r' % (key, value)
15723 
      for key, value in self.__dict__.iteritems()]
15724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15725 
 
15726 
  def __eq__(self, other):
15727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15728 
 
15729 
  def __ne__(self, other):
15730 
    return not (self == other)
4285 rajveer 15731 
 
4324 mandeep.dh 15732 
class updateShipmentAddress_args:
15733 
  """
15734 
  Attributes:
15735 
   - orderId
15736 
   - addressId
15737 
  """
15738 
 
15739 
  thrift_spec = (
15740 
    None, # 0
15741 
    (1, TType.I64, 'orderId', None, None, ), # 1
15742 
    (2, TType.I64, 'addressId', None, None, ), # 2
15743 
  )
15744 
 
15745 
  def __init__(self, orderId=None, addressId=None,):
15746 
    self.orderId = orderId
15747 
    self.addressId = addressId
15748 
 
15749 
  def read(self, iprot):
15750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15752 
      return
15753 
    iprot.readStructBegin()
15754 
    while True:
15755 
      (fname, ftype, fid) = iprot.readFieldBegin()
15756 
      if ftype == TType.STOP:
15757 
        break
15758 
      if fid == 1:
15759 
        if ftype == TType.I64:
15760 
          self.orderId = iprot.readI64();
15761 
        else:
15762 
          iprot.skip(ftype)
15763 
      elif fid == 2:
15764 
        if ftype == TType.I64:
15765 
          self.addressId = iprot.readI64();
15766 
        else:
15767 
          iprot.skip(ftype)
15768 
      else:
15769 
        iprot.skip(ftype)
15770 
      iprot.readFieldEnd()
15771 
    iprot.readStructEnd()
15772 
 
15773 
  def write(self, oprot):
15774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15776 
      return
15777 
    oprot.writeStructBegin('updateShipmentAddress_args')
15778 
    if self.orderId is not None:
15779 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15780 
      oprot.writeI64(self.orderId)
15781 
      oprot.writeFieldEnd()
15782 
    if self.addressId is not None:
15783 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15784 
      oprot.writeI64(self.addressId)
15785 
      oprot.writeFieldEnd()
15786 
    oprot.writeFieldStop()
15787 
    oprot.writeStructEnd()
15788 
 
15789 
  def validate(self):
15790 
    return
15791 
 
15792 
 
15793 
  def __repr__(self):
15794 
    L = ['%s=%r' % (key, value)
15795 
      for key, value in self.__dict__.iteritems()]
15796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15797 
 
15798 
  def __eq__(self, other):
15799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15800 
 
15801 
  def __ne__(self, other):
15802 
    return not (self == other)
15803 
 
15804 
class updateShipmentAddress_result:
15805 
  """
15806 
  Attributes:
15807 
   - ex
15808 
  """
15809 
 
15810 
  thrift_spec = (
15811 
    None, # 0
15812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15813 
  )
15814 
 
15815 
  def __init__(self, ex=None,):
15816 
    self.ex = ex
15817 
 
15818 
  def read(self, iprot):
15819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15821 
      return
15822 
    iprot.readStructBegin()
15823 
    while True:
15824 
      (fname, ftype, fid) = iprot.readFieldBegin()
15825 
      if ftype == TType.STOP:
15826 
        break
15827 
      if fid == 1:
15828 
        if ftype == TType.STRUCT:
15829 
          self.ex = TransactionServiceException()
15830 
          self.ex.read(iprot)
15831 
        else:
15832 
          iprot.skip(ftype)
15833 
      else:
15834 
        iprot.skip(ftype)
15835 
      iprot.readFieldEnd()
15836 
    iprot.readStructEnd()
15837 
 
15838 
  def write(self, oprot):
15839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15841 
      return
15842 
    oprot.writeStructBegin('updateShipmentAddress_result')
15843 
    if self.ex is not None:
15844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15845 
      self.ex.write(oprot)
15846 
      oprot.writeFieldEnd()
15847 
    oprot.writeFieldStop()
15848 
    oprot.writeStructEnd()
15849 
 
15850 
  def validate(self):
15851 
    return
15852 
 
15853 
 
15854 
  def __repr__(self):
15855 
    L = ['%s=%r' % (key, value)
15856 
      for key, value in self.__dict__.iteritems()]
15857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15858 
 
15859 
  def __eq__(self, other):
15860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15861 
 
15862 
  def __ne__(self, other):
15863 
    return not (self == other)
15864 
 
4285 rajveer 15865 
class acceptOrdersForItemId_args:
15866 
  """
15867 
  Attributes:
15868 
   - itemId
15869 
   - inventory
15870 
  """
15871 
 
15872 
  thrift_spec = (
15873 
    None, # 0
15874 
    (1, TType.I64, 'itemId', None, None, ), # 1
15875 
    (2, TType.I64, 'inventory', None, None, ), # 2
15876 
  )
15877 
 
15878 
  def __init__(self, itemId=None, inventory=None,):
15879 
    self.itemId = itemId
15880 
    self.inventory = inventory
15881 
 
15882 
  def read(self, iprot):
15883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15885 
      return
15886 
    iprot.readStructBegin()
15887 
    while True:
15888 
      (fname, ftype, fid) = iprot.readFieldBegin()
15889 
      if ftype == TType.STOP:
15890 
        break
15891 
      if fid == 1:
15892 
        if ftype == TType.I64:
15893 
          self.itemId = iprot.readI64();
15894 
        else:
15895 
          iprot.skip(ftype)
15896 
      elif fid == 2:
15897 
        if ftype == TType.I64:
15898 
          self.inventory = iprot.readI64();
15899 
        else:
15900 
          iprot.skip(ftype)
15901 
      else:
15902 
        iprot.skip(ftype)
15903 
      iprot.readFieldEnd()
15904 
    iprot.readStructEnd()
15905 
 
15906 
  def write(self, oprot):
15907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15909 
      return
15910 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15911 
    if self.itemId is not None:
15912 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15913 
      oprot.writeI64(self.itemId)
15914 
      oprot.writeFieldEnd()
15915 
    if self.inventory is not None:
15916 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15917 
      oprot.writeI64(self.inventory)
15918 
      oprot.writeFieldEnd()
15919 
    oprot.writeFieldStop()
15920 
    oprot.writeStructEnd()
15921 
 
15922 
  def validate(self):
15923 
    return
15924 
 
15925 
 
15926 
  def __repr__(self):
15927 
    L = ['%s=%r' % (key, value)
15928 
      for key, value in self.__dict__.iteritems()]
15929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15930 
 
15931 
  def __eq__(self, other):
15932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15933 
 
15934 
  def __ne__(self, other):
15935 
    return not (self == other)
15936 
 
15937 
class acceptOrdersForItemId_result:
15938 
  """
15939 
  Attributes:
15940 
   - success
15941 
   - ex
15942 
  """
15943 
 
15944 
  thrift_spec = (
15945 
    (0, TType.BOOL, 'success', None, None, ), # 0
15946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15947 
  )
15948 
 
15949 
  def __init__(self, success=None, ex=None,):
15950 
    self.success = success
15951 
    self.ex = ex
15952 
 
15953 
  def read(self, iprot):
15954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15956 
      return
15957 
    iprot.readStructBegin()
15958 
    while True:
15959 
      (fname, ftype, fid) = iprot.readFieldBegin()
15960 
      if ftype == TType.STOP:
15961 
        break
15962 
      if fid == 0:
15963 
        if ftype == TType.BOOL:
15964 
          self.success = iprot.readBool();
15965 
        else:
15966 
          iprot.skip(ftype)
15967 
      elif fid == 1:
15968 
        if ftype == TType.STRUCT:
15969 
          self.ex = TransactionServiceException()
15970 
          self.ex.read(iprot)
15971 
        else:
15972 
          iprot.skip(ftype)
15973 
      else:
15974 
        iprot.skip(ftype)
15975 
      iprot.readFieldEnd()
15976 
    iprot.readStructEnd()
15977 
 
15978 
  def write(self, oprot):
15979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15981 
      return
15982 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15983 
    if self.success is not None:
15984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15985 
      oprot.writeBool(self.success)
15986 
      oprot.writeFieldEnd()
15987 
    if self.ex is not None:
15988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15989 
      self.ex.write(oprot)
15990 
      oprot.writeFieldEnd()
15991 
    oprot.writeFieldStop()
15992 
    oprot.writeStructEnd()
15993 
 
15994 
  def validate(self):
15995 
    return
15996 
 
15997 
 
15998 
  def __repr__(self):
15999 
    L = ['%s=%r' % (key, value)
16000 
      for key, value in self.__dict__.iteritems()]
16001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16002 
 
16003 
  def __eq__(self, other):
16004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16005 
 
16006 
  def __ne__(self, other):
16007 
    return not (self == other)
4303 rajveer 16008 
 
16009 
class markOrdersAsPORaised_args:
16010 
  """
16011 
  Attributes:
16012 
   - vendorId
16013 
   - itemId
16014 
   - quantity
16015 
   - estimate
4369 rajveer 16016 
   - isReminder
4303 rajveer 16017 
  """
16018 
 
16019 
  thrift_spec = (
16020 
    None, # 0
16021 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16022 
    (2, TType.I64, 'itemId', None, None, ), # 2
16023 
    (3, TType.I64, 'quantity', None, None, ), # 3
16024 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16025 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16026 
  )
16027 
 
4369 rajveer 16028 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16029 
    self.vendorId = vendorId
16030 
    self.itemId = itemId
16031 
    self.quantity = quantity
16032 
    self.estimate = estimate
4369 rajveer 16033 
    self.isReminder = isReminder
4303 rajveer 16034 
 
16035 
  def read(self, iprot):
16036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16038 
      return
16039 
    iprot.readStructBegin()
16040 
    while True:
16041 
      (fname, ftype, fid) = iprot.readFieldBegin()
16042 
      if ftype == TType.STOP:
16043 
        break
16044 
      if fid == 1:
16045 
        if ftype == TType.I64:
16046 
          self.vendorId = iprot.readI64();
16047 
        else:
16048 
          iprot.skip(ftype)
16049 
      elif fid == 2:
16050 
        if ftype == TType.I64:
16051 
          self.itemId = iprot.readI64();
16052 
        else:
16053 
          iprot.skip(ftype)
16054 
      elif fid == 3:
16055 
        if ftype == TType.I64:
16056 
          self.quantity = iprot.readI64();
16057 
        else:
16058 
          iprot.skip(ftype)
16059 
      elif fid == 4:
16060 
        if ftype == TType.I64:
16061 
          self.estimate = iprot.readI64();
16062 
        else:
16063 
          iprot.skip(ftype)
4369 rajveer 16064 
      elif fid == 5:
16065 
        if ftype == TType.BOOL:
16066 
          self.isReminder = iprot.readBool();
16067 
        else:
16068 
          iprot.skip(ftype)
4303 rajveer 16069 
      else:
16070 
        iprot.skip(ftype)
16071 
      iprot.readFieldEnd()
16072 
    iprot.readStructEnd()
16073 
 
16074 
  def write(self, oprot):
16075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16077 
      return
16078 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16079 
    if self.vendorId is not None:
16080 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16081 
      oprot.writeI64(self.vendorId)
16082 
      oprot.writeFieldEnd()
16083 
    if self.itemId is not None:
16084 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16085 
      oprot.writeI64(self.itemId)
16086 
      oprot.writeFieldEnd()
16087 
    if self.quantity is not None:
16088 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16089 
      oprot.writeI64(self.quantity)
16090 
      oprot.writeFieldEnd()
16091 
    if self.estimate is not None:
16092 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16093 
      oprot.writeI64(self.estimate)
16094 
      oprot.writeFieldEnd()
4369 rajveer 16095 
    if self.isReminder is not None:
16096 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16097 
      oprot.writeBool(self.isReminder)
16098 
      oprot.writeFieldEnd()
4303 rajveer 16099 
    oprot.writeFieldStop()
16100 
    oprot.writeStructEnd()
16101 
 
16102 
  def validate(self):
16103 
    return
16104 
 
16105 
 
16106 
  def __repr__(self):
16107 
    L = ['%s=%r' % (key, value)
16108 
      for key, value in self.__dict__.iteritems()]
16109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16110 
 
16111 
  def __eq__(self, other):
16112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16113 
 
16114 
  def __ne__(self, other):
16115 
    return not (self == other)
16116 
 
16117 
class markOrdersAsPORaised_result:
16118 
  """
16119 
  Attributes:
16120 
   - ex
16121 
  """
16122 
 
16123 
  thrift_spec = (
16124 
    None, # 0
16125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16126 
  )
16127 
 
16128 
  def __init__(self, ex=None,):
16129 
    self.ex = ex
16130 
 
16131 
  def read(self, iprot):
16132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16134 
      return
16135 
    iprot.readStructBegin()
16136 
    while True:
16137 
      (fname, ftype, fid) = iprot.readFieldBegin()
16138 
      if ftype == TType.STOP:
16139 
        break
16140 
      if fid == 1:
16141 
        if ftype == TType.STRUCT:
16142 
          self.ex = TransactionServiceException()
16143 
          self.ex.read(iprot)
16144 
        else:
16145 
          iprot.skip(ftype)
16146 
      else:
16147 
        iprot.skip(ftype)
16148 
      iprot.readFieldEnd()
16149 
    iprot.readStructEnd()
16150 
 
16151 
  def write(self, oprot):
16152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16154 
      return
16155 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16156 
    if self.ex is not None:
16157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16158 
      self.ex.write(oprot)
16159 
      oprot.writeFieldEnd()
16160 
    oprot.writeFieldStop()
16161 
    oprot.writeStructEnd()
16162 
 
16163 
  def validate(self):
16164 
    return
16165 
 
16166 
 
16167 
  def __repr__(self):
16168 
    L = ['%s=%r' % (key, value)
16169 
      for key, value in self.__dict__.iteritems()]
16170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16171 
 
16172 
  def __eq__(self, other):
16173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16174 
 
16175 
  def __ne__(self, other):
16176 
    return not (self == other)
16177 
 
16178 
class markOrdersAsReversalInitiated_args:
16179 
  """
16180 
  Attributes:
16181 
   - vendorId
16182 
   - itemId
16183 
   - quantity
16184 
   - estimate
4369 rajveer 16185 
   - isReminder
4303 rajveer 16186 
  """
16187 
 
16188 
  thrift_spec = (
16189 
    None, # 0
16190 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16191 
    (2, TType.I64, 'itemId', None, None, ), # 2
16192 
    (3, TType.I64, 'quantity', None, None, ), # 3
16193 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16194 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16195 
  )
16196 
 
4369 rajveer 16197 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16198 
    self.vendorId = vendorId
16199 
    self.itemId = itemId
16200 
    self.quantity = quantity
16201 
    self.estimate = estimate
4369 rajveer 16202 
    self.isReminder = isReminder
4303 rajveer 16203 
 
16204 
  def read(self, iprot):
16205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16207 
      return
16208 
    iprot.readStructBegin()
16209 
    while True:
16210 
      (fname, ftype, fid) = iprot.readFieldBegin()
16211 
      if ftype == TType.STOP:
16212 
        break
16213 
      if fid == 1:
16214 
        if ftype == TType.I64:
16215 
          self.vendorId = iprot.readI64();
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      elif fid == 2:
16219 
        if ftype == TType.I64:
16220 
          self.itemId = iprot.readI64();
16221 
        else:
16222 
          iprot.skip(ftype)
16223 
      elif fid == 3:
16224 
        if ftype == TType.I64:
16225 
          self.quantity = iprot.readI64();
16226 
        else:
16227 
          iprot.skip(ftype)
16228 
      elif fid == 4:
16229 
        if ftype == TType.I64:
16230 
          self.estimate = iprot.readI64();
16231 
        else:
16232 
          iprot.skip(ftype)
4369 rajveer 16233 
      elif fid == 5:
16234 
        if ftype == TType.BOOL:
16235 
          self.isReminder = iprot.readBool();
16236 
        else:
16237 
          iprot.skip(ftype)
4303 rajveer 16238 
      else:
16239 
        iprot.skip(ftype)
16240 
      iprot.readFieldEnd()
16241 
    iprot.readStructEnd()
16242 
 
16243 
  def write(self, oprot):
16244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16246 
      return
16247 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16248 
    if self.vendorId is not None:
16249 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16250 
      oprot.writeI64(self.vendorId)
16251 
      oprot.writeFieldEnd()
16252 
    if self.itemId is not None:
16253 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16254 
      oprot.writeI64(self.itemId)
16255 
      oprot.writeFieldEnd()
16256 
    if self.quantity is not None:
16257 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16258 
      oprot.writeI64(self.quantity)
16259 
      oprot.writeFieldEnd()
16260 
    if self.estimate is not None:
16261 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16262 
      oprot.writeI64(self.estimate)
16263 
      oprot.writeFieldEnd()
4369 rajveer 16264 
    if self.isReminder is not None:
16265 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16266 
      oprot.writeBool(self.isReminder)
16267 
      oprot.writeFieldEnd()
4303 rajveer 16268 
    oprot.writeFieldStop()
16269 
    oprot.writeStructEnd()
16270 
 
16271 
  def validate(self):
16272 
    return
16273 
 
16274 
 
16275 
  def __repr__(self):
16276 
    L = ['%s=%r' % (key, value)
16277 
      for key, value in self.__dict__.iteritems()]
16278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16279 
 
16280 
  def __eq__(self, other):
16281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16282 
 
16283 
  def __ne__(self, other):
16284 
    return not (self == other)
16285 
 
16286 
class markOrdersAsReversalInitiated_result:
16287 
  """
16288 
  Attributes:
16289 
   - ex
16290 
  """
16291 
 
16292 
  thrift_spec = (
16293 
    None, # 0
16294 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16295 
  )
16296 
 
16297 
  def __init__(self, ex=None,):
16298 
    self.ex = ex
16299 
 
16300 
  def read(self, iprot):
16301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16303 
      return
16304 
    iprot.readStructBegin()
16305 
    while True:
16306 
      (fname, ftype, fid) = iprot.readFieldBegin()
16307 
      if ftype == TType.STOP:
16308 
        break
16309 
      if fid == 1:
16310 
        if ftype == TType.STRUCT:
16311 
          self.ex = TransactionServiceException()
16312 
          self.ex.read(iprot)
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      else:
16316 
        iprot.skip(ftype)
16317 
      iprot.readFieldEnd()
16318 
    iprot.readStructEnd()
16319 
 
16320 
  def write(self, oprot):
16321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16323 
      return
16324 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16325 
    if self.ex is not None:
16326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16327 
      self.ex.write(oprot)
16328 
      oprot.writeFieldEnd()
16329 
    oprot.writeFieldStop()
16330 
    oprot.writeStructEnd()
16331 
 
16332 
  def validate(self):
16333 
    return
16334 
 
16335 
 
16336 
  def __repr__(self):
16337 
    L = ['%s=%r' % (key, value)
16338 
      for key, value in self.__dict__.iteritems()]
16339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16340 
 
16341 
  def __eq__(self, other):
16342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16343 
 
16344 
  def __ne__(self, other):
16345 
    return not (self == other)
16346 
 
16347 
class markOrdersAsNotAvailabke_args:
16348 
  """
16349 
  Attributes:
16350 
   - vendorId
16351 
   - itemId
16352 
   - quantity
16353 
   - estimate
4369 rajveer 16354 
   - isReminder
4303 rajveer 16355 
  """
16356 
 
16357 
  thrift_spec = (
16358 
    None, # 0
16359 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16360 
    (2, TType.I64, 'itemId', None, None, ), # 2
16361 
    (3, TType.I64, 'quantity', None, None, ), # 3
16362 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16363 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16364 
  )
16365 
 
4369 rajveer 16366 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16367 
    self.vendorId = vendorId
16368 
    self.itemId = itemId
16369 
    self.quantity = quantity
16370 
    self.estimate = estimate
4369 rajveer 16371 
    self.isReminder = isReminder
4303 rajveer 16372 
 
16373 
  def read(self, iprot):
16374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16376 
      return
16377 
    iprot.readStructBegin()
16378 
    while True:
16379 
      (fname, ftype, fid) = iprot.readFieldBegin()
16380 
      if ftype == TType.STOP:
16381 
        break
16382 
      if fid == 1:
16383 
        if ftype == TType.I64:
16384 
          self.vendorId = iprot.readI64();
16385 
        else:
16386 
          iprot.skip(ftype)
16387 
      elif fid == 2:
16388 
        if ftype == TType.I64:
16389 
          self.itemId = iprot.readI64();
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      elif fid == 3:
16393 
        if ftype == TType.I64:
16394 
          self.quantity = iprot.readI64();
16395 
        else:
16396 
          iprot.skip(ftype)
16397 
      elif fid == 4:
16398 
        if ftype == TType.I64:
16399 
          self.estimate = iprot.readI64();
16400 
        else:
16401 
          iprot.skip(ftype)
4369 rajveer 16402 
      elif fid == 5:
16403 
        if ftype == TType.BOOL:
16404 
          self.isReminder = iprot.readBool();
16405 
        else:
16406 
          iprot.skip(ftype)
4303 rajveer 16407 
      else:
16408 
        iprot.skip(ftype)
16409 
      iprot.readFieldEnd()
16410 
    iprot.readStructEnd()
16411 
 
16412 
  def write(self, oprot):
16413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16415 
      return
16416 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16417 
    if self.vendorId is not None:
16418 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16419 
      oprot.writeI64(self.vendorId)
16420 
      oprot.writeFieldEnd()
16421 
    if self.itemId is not None:
16422 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16423 
      oprot.writeI64(self.itemId)
16424 
      oprot.writeFieldEnd()
16425 
    if self.quantity is not None:
16426 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16427 
      oprot.writeI64(self.quantity)
16428 
      oprot.writeFieldEnd()
16429 
    if self.estimate is not None:
16430 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16431 
      oprot.writeI64(self.estimate)
16432 
      oprot.writeFieldEnd()
4369 rajveer 16433 
    if self.isReminder is not None:
16434 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16435 
      oprot.writeBool(self.isReminder)
16436 
      oprot.writeFieldEnd()
4303 rajveer 16437 
    oprot.writeFieldStop()
16438 
    oprot.writeStructEnd()
16439 
 
16440 
  def validate(self):
16441 
    return
16442 
 
16443 
 
16444 
  def __repr__(self):
16445 
    L = ['%s=%r' % (key, value)
16446 
      for key, value in self.__dict__.iteritems()]
16447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16448 
 
16449 
  def __eq__(self, other):
16450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16451 
 
16452 
  def __ne__(self, other):
16453 
    return not (self == other)
16454 
 
16455 
class markOrdersAsNotAvailabke_result:
16456 
  """
16457 
  Attributes:
16458 
   - ex
16459 
  """
16460 
 
16461 
  thrift_spec = (
16462 
    None, # 0
16463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16464 
  )
16465 
 
16466 
  def __init__(self, ex=None,):
16467 
    self.ex = ex
16468 
 
16469 
  def read(self, iprot):
16470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16472 
      return
16473 
    iprot.readStructBegin()
16474 
    while True:
16475 
      (fname, ftype, fid) = iprot.readFieldBegin()
16476 
      if ftype == TType.STOP:
16477 
        break
16478 
      if fid == 1:
16479 
        if ftype == TType.STRUCT:
16480 
          self.ex = TransactionServiceException()
16481 
          self.ex.read(iprot)
16482 
        else:
16483 
          iprot.skip(ftype)
16484 
      else:
16485 
        iprot.skip(ftype)
16486 
      iprot.readFieldEnd()
16487 
    iprot.readStructEnd()
16488 
 
16489 
  def write(self, oprot):
16490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16492 
      return
16493 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16494 
    if self.ex is not None:
16495 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16496 
      self.ex.write(oprot)
16497 
      oprot.writeFieldEnd()
16498 
    oprot.writeFieldStop()
16499 
    oprot.writeStructEnd()
16500 
 
16501 
  def validate(self):
16502 
    return
16503 
 
16504 
 
16505 
  def __repr__(self):
16506 
    L = ['%s=%r' % (key, value)
16507 
      for key, value in self.__dict__.iteritems()]
16508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16509 
 
16510 
  def __eq__(self, other):
16511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16512 
 
16513 
  def __ne__(self, other):
16514 
    return not (self == other)
4369 rajveer 16515 
 
16516 
class markOrdersAsTimeout_args:
16517 
  """
16518 
  Attributes:
16519 
   - vendorId
16520 
  """
16521 
 
16522 
  thrift_spec = (
16523 
    None, # 0
16524 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16525 
  )
16526 
 
16527 
  def __init__(self, vendorId=None,):
16528 
    self.vendorId = vendorId
16529 
 
16530 
  def read(self, iprot):
16531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16533 
      return
16534 
    iprot.readStructBegin()
16535 
    while True:
16536 
      (fname, ftype, fid) = iprot.readFieldBegin()
16537 
      if ftype == TType.STOP:
16538 
        break
16539 
      if fid == 1:
16540 
        if ftype == TType.I64:
16541 
          self.vendorId = iprot.readI64();
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      else:
16545 
        iprot.skip(ftype)
16546 
      iprot.readFieldEnd()
16547 
    iprot.readStructEnd()
16548 
 
16549 
  def write(self, oprot):
16550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16552 
      return
16553 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16554 
    if self.vendorId is not None:
16555 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16556 
      oprot.writeI64(self.vendorId)
16557 
      oprot.writeFieldEnd()
16558 
    oprot.writeFieldStop()
16559 
    oprot.writeStructEnd()
16560 
 
16561 
  def validate(self):
16562 
    return
16563 
 
16564 
 
16565 
  def __repr__(self):
16566 
    L = ['%s=%r' % (key, value)
16567 
      for key, value in self.__dict__.iteritems()]
16568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16569 
 
16570 
  def __eq__(self, other):
16571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16572 
 
16573 
  def __ne__(self, other):
16574 
    return not (self == other)
16575 
 
16576 
class markOrdersAsTimeout_result:
16577 
  """
16578 
  Attributes:
16579 
   - success
16580 
   - ex
16581 
  """
16582 
 
16583 
  thrift_spec = (
16584 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16586 
  )
16587 
 
16588 
  def __init__(self, success=None, ex=None,):
16589 
    self.success = success
16590 
    self.ex = ex
16591 
 
16592 
  def read(self, iprot):
16593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16595 
      return
16596 
    iprot.readStructBegin()
16597 
    while True:
16598 
      (fname, ftype, fid) = iprot.readFieldBegin()
16599 
      if ftype == TType.STOP:
16600 
        break
16601 
      if fid == 0:
16602 
        if ftype == TType.MAP:
16603 
          self.success = {}
4586 mandeep.dh 16604 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16605 
          for _i279 in xrange(_size275):
16606 
            _key280 = iprot.readI32();
16607 
            _val281 = TimeoutSummary()
16608 
            _val281.read(iprot)
16609 
            self.success[_key280] = _val281
4369 rajveer 16610 
          iprot.readMapEnd()
16611 
        else:
16612 
          iprot.skip(ftype)
16613 
      elif fid == 1:
16614 
        if ftype == TType.STRUCT:
16615 
          self.ex = TransactionServiceException()
16616 
          self.ex.read(iprot)
16617 
        else:
16618 
          iprot.skip(ftype)
16619 
      else:
16620 
        iprot.skip(ftype)
16621 
      iprot.readFieldEnd()
16622 
    iprot.readStructEnd()
16623 
 
16624 
  def write(self, oprot):
16625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16627 
      return
16628 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16629 
    if self.success is not None:
16630 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16631 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16632 
      for kiter282,viter283 in self.success.items():
16633 
        oprot.writeI32(kiter282)
16634 
        viter283.write(oprot)
4369 rajveer 16635 
      oprot.writeMapEnd()
16636 
      oprot.writeFieldEnd()
16637 
    if self.ex is not None:
16638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16639 
      self.ex.write(oprot)
16640 
      oprot.writeFieldEnd()
16641 
    oprot.writeFieldStop()
16642 
    oprot.writeStructEnd()
16643 
 
16644 
  def validate(self):
16645 
    return
16646 
 
16647 
 
16648 
  def __repr__(self):
16649 
    L = ['%s=%r' % (key, value)
16650 
      for key, value in self.__dict__.iteritems()]
16651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16652 
 
16653 
  def __eq__(self, other):
16654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16655 
 
16656 
  def __ne__(self, other):
16657 
    return not (self == other)
4386 anupam.sin 16658 
 
16659 
class getOrderForAwb_args:
16660 
  """
16661 
  Attributes:
16662 
   - awb
16663 
  """
16664 
 
16665 
  thrift_spec = (
16666 
    None, # 0
16667 
    (1, TType.STRING, 'awb', None, None, ), # 1
16668 
  )
16669 
 
16670 
  def __init__(self, awb=None,):
16671 
    self.awb = awb
16672 
 
16673 
  def read(self, iprot):
16674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16676 
      return
16677 
    iprot.readStructBegin()
16678 
    while True:
16679 
      (fname, ftype, fid) = iprot.readFieldBegin()
16680 
      if ftype == TType.STOP:
16681 
        break
16682 
      if fid == 1:
16683 
        if ftype == TType.STRING:
16684 
          self.awb = iprot.readString();
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('getOrderForAwb_args')
16697 
    if self.awb is not None:
16698 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16699 
      oprot.writeString(self.awb)
16700 
      oprot.writeFieldEnd()
16701 
    oprot.writeFieldStop()
16702 
    oprot.writeStructEnd()
16703 
 
16704 
  def validate(self):
16705 
    return
16706 
 
16707 
 
16708 
  def __repr__(self):
16709 
    L = ['%s=%r' % (key, value)
16710 
      for key, value in self.__dict__.iteritems()]
16711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16712 
 
16713 
  def __eq__(self, other):
16714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16715 
 
16716 
  def __ne__(self, other):
16717 
    return not (self == other)
16718 
 
16719 
class getOrderForAwb_result:
16720 
  """
16721 
  Attributes:
16722 
   - success
16723 
   - ex
16724 
  """
16725 
 
16726 
  thrift_spec = (
16727 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16729 
  )
16730 
 
16731 
  def __init__(self, success=None, ex=None,):
16732 
    self.success = success
16733 
    self.ex = ex
16734 
 
16735 
  def read(self, iprot):
16736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16738 
      return
16739 
    iprot.readStructBegin()
16740 
    while True:
16741 
      (fname, ftype, fid) = iprot.readFieldBegin()
16742 
      if ftype == TType.STOP:
16743 
        break
16744 
      if fid == 0:
16745 
        if ftype == TType.STRUCT:
16746 
          self.success = Order()
16747 
          self.success.read(iprot)
16748 
        else:
16749 
          iprot.skip(ftype)
16750 
      elif fid == 1:
16751 
        if ftype == TType.STRUCT:
16752 
          self.ex = TransactionServiceException()
16753 
          self.ex.read(iprot)
16754 
        else:
16755 
          iprot.skip(ftype)
16756 
      else:
16757 
        iprot.skip(ftype)
16758 
      iprot.readFieldEnd()
16759 
    iprot.readStructEnd()
16760 
 
16761 
  def write(self, oprot):
16762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16764 
      return
16765 
    oprot.writeStructBegin('getOrderForAwb_result')
16766 
    if self.success is not None:
16767 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16768 
      self.success.write(oprot)
16769 
      oprot.writeFieldEnd()
16770 
    if self.ex is not None:
16771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16772 
      self.ex.write(oprot)
16773 
      oprot.writeFieldEnd()
16774 
    oprot.writeFieldStop()
16775 
    oprot.writeStructEnd()
16776 
 
16777 
  def validate(self):
16778 
    return
16779 
 
16780 
 
16781 
  def __repr__(self):
16782 
    L = ['%s=%r' % (key, value)
16783 
      for key, value in self.__dict__.iteritems()]
16784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16785 
 
16786 
  def __eq__(self, other):
16787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16788 
 
16789 
  def __ne__(self, other):
16790 
    return not (self == other)
4506 phani.kuma 16791 
 
16792 
class getOrdersForProviderForStatus_args:
16793 
  """
16794 
  Attributes:
16795 
   - logistics_provider_id
16796 
   - order_status
16797 
  """
16798 
 
16799 
  thrift_spec = (
16800 
    None, # 0
16801 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16802 
    (2, TType.I32, 'order_status', None, None, ), # 2
16803 
  )
16804 
 
16805 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16806 
    self.logistics_provider_id = logistics_provider_id
16807 
    self.order_status = order_status
16808 
 
16809 
  def read(self, iprot):
16810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16812 
      return
16813 
    iprot.readStructBegin()
16814 
    while True:
16815 
      (fname, ftype, fid) = iprot.readFieldBegin()
16816 
      if ftype == TType.STOP:
16817 
        break
16818 
      if fid == 1:
16819 
        if ftype == TType.I64:
16820 
          self.logistics_provider_id = iprot.readI64();
16821 
        else:
16822 
          iprot.skip(ftype)
16823 
      elif fid == 2:
16824 
        if ftype == TType.I32:
16825 
          self.order_status = iprot.readI32();
16826 
        else:
16827 
          iprot.skip(ftype)
16828 
      else:
16829 
        iprot.skip(ftype)
16830 
      iprot.readFieldEnd()
16831 
    iprot.readStructEnd()
16832 
 
16833 
  def write(self, oprot):
16834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16836 
      return
16837 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16838 
    if self.logistics_provider_id is not None:
16839 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16840 
      oprot.writeI64(self.logistics_provider_id)
16841 
      oprot.writeFieldEnd()
16842 
    if self.order_status is not None:
16843 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16844 
      oprot.writeI32(self.order_status)
16845 
      oprot.writeFieldEnd()
16846 
    oprot.writeFieldStop()
16847 
    oprot.writeStructEnd()
16848 
 
16849 
  def validate(self):
16850 
    return
16851 
 
16852 
 
16853 
  def __repr__(self):
16854 
    L = ['%s=%r' % (key, value)
16855 
      for key, value in self.__dict__.iteritems()]
16856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16857 
 
16858 
  def __eq__(self, other):
16859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16860 
 
16861 
  def __ne__(self, other):
16862 
    return not (self == other)
16863 
 
16864 
class getOrdersForProviderForStatus_result:
16865 
  """
16866 
  Attributes:
16867 
   - success
16868 
   - ex
16869 
  """
16870 
 
16871 
  thrift_spec = (
16872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16874 
  )
16875 
 
16876 
  def __init__(self, success=None, ex=None,):
16877 
    self.success = success
16878 
    self.ex = ex
16879 
 
16880 
  def read(self, iprot):
16881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16883 
      return
16884 
    iprot.readStructBegin()
16885 
    while True:
16886 
      (fname, ftype, fid) = iprot.readFieldBegin()
16887 
      if ftype == TType.STOP:
16888 
        break
16889 
      if fid == 0:
16890 
        if ftype == TType.LIST:
16891 
          self.success = []
4586 mandeep.dh 16892 
          (_etype287, _size284) = iprot.readListBegin()
16893 
          for _i288 in xrange(_size284):
16894 
            _elem289 = Order()
16895 
            _elem289.read(iprot)
16896 
            self.success.append(_elem289)
4506 phani.kuma 16897 
          iprot.readListEnd()
16898 
        else:
16899 
          iprot.skip(ftype)
16900 
      elif fid == 1:
16901 
        if ftype == TType.STRUCT:
16902 
          self.ex = TransactionServiceException()
16903 
          self.ex.read(iprot)
16904 
        else:
16905 
          iprot.skip(ftype)
16906 
      else:
16907 
        iprot.skip(ftype)
16908 
      iprot.readFieldEnd()
16909 
    iprot.readStructEnd()
16910 
 
16911 
  def write(self, oprot):
16912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16914 
      return
16915 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16916 
    if self.success is not None:
16917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 16919 
      for iter290 in self.success:
16920 
        iter290.write(oprot)
4506 phani.kuma 16921 
      oprot.writeListEnd()
16922 
      oprot.writeFieldEnd()
16923 
    if self.ex is not None:
16924 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16925 
      self.ex.write(oprot)
16926 
      oprot.writeFieldEnd()
16927 
    oprot.writeFieldStop()
16928 
    oprot.writeStructEnd()
16929 
 
16930 
  def validate(self):
16931 
    return
16932 
 
16933 
 
16934 
  def __repr__(self):
16935 
    L = ['%s=%r' % (key, value)
16936 
      for key, value in self.__dict__.iteritems()]
16937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16938 
 
16939 
  def __eq__(self, other):
16940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16941 
 
16942 
  def __ne__(self, other):
16943 
    return not (self == other)
4600 varun.gupt 16944 
 
16945 
class getBilledOrdersForVendor_args:
16946 
  """
16947 
  Attributes:
16948 
   - vendorId
16949 
   - billingDateFrom
16950 
   - billingDateTo
16951 
  """
16952 
 
16953 
  thrift_spec = (
16954 
    None, # 0
16955 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16956 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
16957 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
16958 
  )
16959 
 
16960 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
16961 
    self.vendorId = vendorId
16962 
    self.billingDateFrom = billingDateFrom
16963 
    self.billingDateTo = billingDateTo
16964 
 
16965 
  def read(self, iprot):
16966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16968 
      return
16969 
    iprot.readStructBegin()
16970 
    while True:
16971 
      (fname, ftype, fid) = iprot.readFieldBegin()
16972 
      if ftype == TType.STOP:
16973 
        break
16974 
      if fid == 1:
16975 
        if ftype == TType.I64:
16976 
          self.vendorId = iprot.readI64();
16977 
        else:
16978 
          iprot.skip(ftype)
16979 
      elif fid == 2:
16980 
        if ftype == TType.I64:
16981 
          self.billingDateFrom = iprot.readI64();
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      elif fid == 3:
16985 
        if ftype == TType.I64:
16986 
          self.billingDateTo = iprot.readI64();
16987 
        else:
16988 
          iprot.skip(ftype)
16989 
      else:
16990 
        iprot.skip(ftype)
16991 
      iprot.readFieldEnd()
16992 
    iprot.readStructEnd()
16993 
 
16994 
  def write(self, oprot):
16995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16997 
      return
16998 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
16999 
    if self.vendorId is not None:
17000 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17001 
      oprot.writeI64(self.vendorId)
17002 
      oprot.writeFieldEnd()
17003 
    if self.billingDateFrom is not None:
17004 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17005 
      oprot.writeI64(self.billingDateFrom)
17006 
      oprot.writeFieldEnd()
17007 
    if self.billingDateTo is not None:
17008 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17009 
      oprot.writeI64(self.billingDateTo)
17010 
      oprot.writeFieldEnd()
17011 
    oprot.writeFieldStop()
17012 
    oprot.writeStructEnd()
17013 
 
17014 
  def validate(self):
17015 
    return
17016 
 
17017 
 
17018 
  def __repr__(self):
17019 
    L = ['%s=%r' % (key, value)
17020 
      for key, value in self.__dict__.iteritems()]
17021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17022 
 
17023 
  def __eq__(self, other):
17024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17025 
 
17026 
  def __ne__(self, other):
17027 
    return not (self == other)
17028 
 
17029 
class getBilledOrdersForVendor_result:
17030 
  """
17031 
  Attributes:
17032 
   - success
17033 
   - ex
17034 
  """
17035 
 
17036 
  thrift_spec = (
17037 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17039 
  )
17040 
 
17041 
  def __init__(self, success=None, ex=None,):
17042 
    self.success = success
17043 
    self.ex = ex
17044 
 
17045 
  def read(self, iprot):
17046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17048 
      return
17049 
    iprot.readStructBegin()
17050 
    while True:
17051 
      (fname, ftype, fid) = iprot.readFieldBegin()
17052 
      if ftype == TType.STOP:
17053 
        break
17054 
      if fid == 0:
17055 
        if ftype == TType.LIST:
17056 
          self.success = []
17057 
          (_etype294, _size291) = iprot.readListBegin()
17058 
          for _i295 in xrange(_size291):
17059 
            _elem296 = Order()
17060 
            _elem296.read(iprot)
17061 
            self.success.append(_elem296)
17062 
          iprot.readListEnd()
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      elif fid == 1:
17066 
        if ftype == TType.STRUCT:
17067 
          self.ex = TransactionServiceException()
17068 
          self.ex.read(iprot)
17069 
        else:
17070 
          iprot.skip(ftype)
17071 
      else:
17072 
        iprot.skip(ftype)
17073 
      iprot.readFieldEnd()
17074 
    iprot.readStructEnd()
17075 
 
17076 
  def write(self, oprot):
17077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17079 
      return
17080 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17081 
    if self.success is not None:
17082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17084 
      for iter297 in self.success:
17085 
        iter297.write(oprot)
17086 
      oprot.writeListEnd()
17087 
      oprot.writeFieldEnd()
17088 
    if self.ex is not None:
17089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17090 
      self.ex.write(oprot)
17091 
      oprot.writeFieldEnd()
17092 
    oprot.writeFieldStop()
17093 
    oprot.writeStructEnd()
17094 
 
17095 
  def validate(self):
17096 
    return
17097 
 
17098 
 
17099 
  def __repr__(self):
17100 
    L = ['%s=%r' % (key, value)
17101 
      for key, value in self.__dict__.iteritems()]
17102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17103 
 
17104 
  def __eq__(self, other):
17105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17106 
 
17107 
  def __ne__(self, other):
17108 
    return not (self == other)
17109 
 
17110 
class saveBluedartSettlements_args:
17111 
  """
17112 
  Attributes:
17113 
   - mapAWBAndAmount
17114 
  """
17115 
 
17116 
  thrift_spec = (
17117 
    None, # 0
17118 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17119 
  )
17120 
 
17121 
  def __init__(self, mapAWBAndAmount=None,):
17122 
    self.mapAWBAndAmount = mapAWBAndAmount
17123 
 
17124 
  def read(self, iprot):
17125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17127 
      return
17128 
    iprot.readStructBegin()
17129 
    while True:
17130 
      (fname, ftype, fid) = iprot.readFieldBegin()
17131 
      if ftype == TType.STOP:
17132 
        break
17133 
      if fid == 1:
17134 
        if ftype == TType.MAP:
17135 
          self.mapAWBAndAmount = {}
17136 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
17137 
          for _i302 in xrange(_size298):
17138 
            _key303 = iprot.readI64();
17139 
            _val304 = iprot.readDouble();
17140 
            self.mapAWBAndAmount[_key303] = _val304
17141 
          iprot.readMapEnd()
17142 
        else:
17143 
          iprot.skip(ftype)
17144 
      else:
17145 
        iprot.skip(ftype)
17146 
      iprot.readFieldEnd()
17147 
    iprot.readStructEnd()
17148 
 
17149 
  def write(self, oprot):
17150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17152 
      return
17153 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17154 
    if self.mapAWBAndAmount is not None:
17155 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17156 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
17157 
      for kiter305,viter306 in self.mapAWBAndAmount.items():
17158 
        oprot.writeI64(kiter305)
17159 
        oprot.writeDouble(viter306)
17160 
      oprot.writeMapEnd()
17161 
      oprot.writeFieldEnd()
17162 
    oprot.writeFieldStop()
17163 
    oprot.writeStructEnd()
17164 
 
17165 
  def validate(self):
17166 
    return
17167 
 
17168 
 
17169 
  def __repr__(self):
17170 
    L = ['%s=%r' % (key, value)
17171 
      for key, value in self.__dict__.iteritems()]
17172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17173 
 
17174 
  def __eq__(self, other):
17175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17176 
 
17177 
  def __ne__(self, other):
17178 
    return not (self == other)
17179 
 
17180 
class saveBluedartSettlements_result:
17181 
  """
17182 
  Attributes:
17183 
   - ex
17184 
  """
17185 
 
17186 
  thrift_spec = (
17187 
    None, # 0
17188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17189 
  )
17190 
 
17191 
  def __init__(self, ex=None,):
17192 
    self.ex = ex
17193 
 
17194 
  def read(self, iprot):
17195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17197 
      return
17198 
    iprot.readStructBegin()
17199 
    while True:
17200 
      (fname, ftype, fid) = iprot.readFieldBegin()
17201 
      if ftype == TType.STOP:
17202 
        break
17203 
      if fid == 1:
17204 
        if ftype == TType.STRUCT:
17205 
          self.ex = TransactionServiceException()
17206 
          self.ex.read(iprot)
17207 
        else:
17208 
          iprot.skip(ftype)
17209 
      else:
17210 
        iprot.skip(ftype)
17211 
      iprot.readFieldEnd()
17212 
    iprot.readStructEnd()
17213 
 
17214 
  def write(self, oprot):
17215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17217 
      return
17218 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17219 
    if self.ex is not None:
17220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17221 
      self.ex.write(oprot)
17222 
      oprot.writeFieldEnd()
17223 
    oprot.writeFieldStop()
17224 
    oprot.writeStructEnd()
17225 
 
17226 
  def validate(self):
17227 
    return
17228 
 
17229 
 
17230 
  def __repr__(self):
17231 
    L = ['%s=%r' % (key, value)
17232 
      for key, value in self.__dict__.iteritems()]
17233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17234 
 
17235 
  def __eq__(self, other):
17236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17237 
 
17238 
  def __ne__(self, other):
17239 
    return not (self == other)
17240 
 
17241 
class savePaymentSettlements_args:
17242 
  """
17243 
  Attributes:
17244 
   - settlementDate
17245 
   - paymentGatewayId
17246 
   - paymentId
17247 
   - serviceTax
17248 
   - otherCharges
17249 
   - netCollection
17250 
  """
17251 
 
17252 
  thrift_spec = (
17253 
    None, # 0
17254 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17255 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17256 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17257 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17258 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17259 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17260 
  )
17261 
 
17262 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17263 
    self.settlementDate = settlementDate
17264 
    self.paymentGatewayId = paymentGatewayId
17265 
    self.paymentId = paymentId
17266 
    self.serviceTax = serviceTax
17267 
    self.otherCharges = otherCharges
17268 
    self.netCollection = netCollection
17269 
 
17270 
  def read(self, iprot):
17271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17273 
      return
17274 
    iprot.readStructBegin()
17275 
    while True:
17276 
      (fname, ftype, fid) = iprot.readFieldBegin()
17277 
      if ftype == TType.STOP:
17278 
        break
17279 
      if fid == 1:
17280 
        if ftype == TType.I64:
17281 
          self.settlementDate = iprot.readI64();
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      elif fid == 2:
17285 
        if ftype == TType.I64:
17286 
          self.paymentGatewayId = iprot.readI64();
17287 
        else:
17288 
          iprot.skip(ftype)
17289 
      elif fid == 3:
17290 
        if ftype == TType.I64:
17291 
          self.paymentId = iprot.readI64();
17292 
        else:
17293 
          iprot.skip(ftype)
17294 
      elif fid == 4:
17295 
        if ftype == TType.DOUBLE:
17296 
          self.serviceTax = iprot.readDouble();
17297 
        else:
17298 
          iprot.skip(ftype)
17299 
      elif fid == 5:
17300 
        if ftype == TType.DOUBLE:
17301 
          self.otherCharges = iprot.readDouble();
17302 
        else:
17303 
          iprot.skip(ftype)
17304 
      elif fid == 6:
17305 
        if ftype == TType.DOUBLE:
17306 
          self.netCollection = iprot.readDouble();
17307 
        else:
17308 
          iprot.skip(ftype)
17309 
      else:
17310 
        iprot.skip(ftype)
17311 
      iprot.readFieldEnd()
17312 
    iprot.readStructEnd()
17313 
 
17314 
  def write(self, oprot):
17315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17317 
      return
17318 
    oprot.writeStructBegin('savePaymentSettlements_args')
17319 
    if self.settlementDate is not None:
17320 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17321 
      oprot.writeI64(self.settlementDate)
17322 
      oprot.writeFieldEnd()
17323 
    if self.paymentGatewayId is not None:
17324 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17325 
      oprot.writeI64(self.paymentGatewayId)
17326 
      oprot.writeFieldEnd()
17327 
    if self.paymentId is not None:
17328 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17329 
      oprot.writeI64(self.paymentId)
17330 
      oprot.writeFieldEnd()
17331 
    if self.serviceTax is not None:
17332 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17333 
      oprot.writeDouble(self.serviceTax)
17334 
      oprot.writeFieldEnd()
17335 
    if self.otherCharges is not None:
17336 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17337 
      oprot.writeDouble(self.otherCharges)
17338 
      oprot.writeFieldEnd()
17339 
    if self.netCollection is not None:
17340 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17341 
      oprot.writeDouble(self.netCollection)
17342 
      oprot.writeFieldEnd()
17343 
    oprot.writeFieldStop()
17344 
    oprot.writeStructEnd()
17345 
 
17346 
  def validate(self):
17347 
    return
17348 
 
17349 
 
17350 
  def __repr__(self):
17351 
    L = ['%s=%r' % (key, value)
17352 
      for key, value in self.__dict__.iteritems()]
17353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17354 
 
17355 
  def __eq__(self, other):
17356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17357 
 
17358 
  def __ne__(self, other):
17359 
    return not (self == other)
17360 
 
17361 
class savePaymentSettlements_result:
17362 
  """
17363 
  Attributes:
17364 
   - ex
17365 
  """
17366 
 
17367 
  thrift_spec = (
17368 
    None, # 0
17369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17370 
  )
17371 
 
17372 
  def __init__(self, ex=None,):
17373 
    self.ex = ex
17374 
 
17375 
  def read(self, iprot):
17376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17378 
      return
17379 
    iprot.readStructBegin()
17380 
    while True:
17381 
      (fname, ftype, fid) = iprot.readFieldBegin()
17382 
      if ftype == TType.STOP:
17383 
        break
17384 
      if fid == 1:
17385 
        if ftype == TType.STRUCT:
17386 
          self.ex = TransactionServiceException()
17387 
          self.ex.read(iprot)
17388 
        else:
17389 
          iprot.skip(ftype)
17390 
      else:
17391 
        iprot.skip(ftype)
17392 
      iprot.readFieldEnd()
17393 
    iprot.readStructEnd()
17394 
 
17395 
  def write(self, oprot):
17396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17398 
      return
17399 
    oprot.writeStructBegin('savePaymentSettlements_result')
17400 
    if self.ex is not None:
17401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17402 
      self.ex.write(oprot)
17403 
      oprot.writeFieldEnd()
17404 
    oprot.writeFieldStop()
17405 
    oprot.writeStructEnd()
17406 
 
17407 
  def validate(self):
17408 
    return
17409 
 
17410 
 
17411 
  def __repr__(self):
17412 
    L = ['%s=%r' % (key, value)
17413 
      for key, value in self.__dict__.iteritems()]
17414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17415 
 
17416 
  def __eq__(self, other):
17417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17418 
 
17419 
  def __ne__(self, other):
17420 
    return not (self == other)
17421 
 
17422 
class saveEBSSettlementSummary_args:
17423 
  """
17424 
  Attributes:
17425 
   - settlementId
17426 
   - settlementDate
17427 
   - transactionDateFrom
17428 
   - transactionDateTo
17429 
   - amount
17430 
  """
17431 
 
17432 
  thrift_spec = (
17433 
    None, # 0
17434 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17435 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
17436 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
17437 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
17438 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
17439 
  )
17440 
 
17441 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
17442 
    self.settlementId = settlementId
17443 
    self.settlementDate = settlementDate
17444 
    self.transactionDateFrom = transactionDateFrom
17445 
    self.transactionDateTo = transactionDateTo
17446 
    self.amount = amount
17447 
 
17448 
  def read(self, iprot):
17449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17451 
      return
17452 
    iprot.readStructBegin()
17453 
    while True:
17454 
      (fname, ftype, fid) = iprot.readFieldBegin()
17455 
      if ftype == TType.STOP:
17456 
        break
17457 
      if fid == 1:
17458 
        if ftype == TType.I64:
17459 
          self.settlementId = iprot.readI64();
17460 
        else:
17461 
          iprot.skip(ftype)
17462 
      elif fid == 2:
17463 
        if ftype == TType.I64:
17464 
          self.settlementDate = iprot.readI64();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      elif fid == 3:
17468 
        if ftype == TType.I64:
17469 
          self.transactionDateFrom = iprot.readI64();
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 4:
17473 
        if ftype == TType.I64:
17474 
          self.transactionDateTo = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      elif fid == 5:
17478 
        if ftype == TType.DOUBLE:
17479 
          self.amount = iprot.readDouble();
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      else:
17483 
        iprot.skip(ftype)
17484 
      iprot.readFieldEnd()
17485 
    iprot.readStructEnd()
17486 
 
17487 
  def write(self, oprot):
17488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17490 
      return
17491 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
17492 
    if self.settlementId is not None:
17493 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17494 
      oprot.writeI64(self.settlementId)
17495 
      oprot.writeFieldEnd()
17496 
    if self.settlementDate is not None:
17497 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
17498 
      oprot.writeI64(self.settlementDate)
17499 
      oprot.writeFieldEnd()
17500 
    if self.transactionDateFrom is not None:
17501 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
17502 
      oprot.writeI64(self.transactionDateFrom)
17503 
      oprot.writeFieldEnd()
17504 
    if self.transactionDateTo is not None:
17505 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
17506 
      oprot.writeI64(self.transactionDateTo)
17507 
      oprot.writeFieldEnd()
17508 
    if self.amount is not None:
17509 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
17510 
      oprot.writeDouble(self.amount)
17511 
      oprot.writeFieldEnd()
17512 
    oprot.writeFieldStop()
17513 
    oprot.writeStructEnd()
17514 
 
17515 
  def validate(self):
17516 
    return
17517 
 
17518 
 
17519 
  def __repr__(self):
17520 
    L = ['%s=%r' % (key, value)
17521 
      for key, value in self.__dict__.iteritems()]
17522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17523 
 
17524 
  def __eq__(self, other):
17525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17526 
 
17527 
  def __ne__(self, other):
17528 
    return not (self == other)
17529 
 
17530 
class saveEBSSettlementSummary_result:
17531 
  """
17532 
  Attributes:
17533 
   - ex
17534 
  """
17535 
 
17536 
  thrift_spec = (
17537 
    None, # 0
17538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17539 
  )
17540 
 
17541 
  def __init__(self, ex=None,):
17542 
    self.ex = ex
17543 
 
17544 
  def read(self, iprot):
17545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17547 
      return
17548 
    iprot.readStructBegin()
17549 
    while True:
17550 
      (fname, ftype, fid) = iprot.readFieldBegin()
17551 
      if ftype == TType.STOP:
17552 
        break
17553 
      if fid == 1:
17554 
        if ftype == TType.STRUCT:
17555 
          self.ex = TransactionServiceException()
17556 
          self.ex.read(iprot)
17557 
        else:
17558 
          iprot.skip(ftype)
17559 
      else:
17560 
        iprot.skip(ftype)
17561 
      iprot.readFieldEnd()
17562 
    iprot.readStructEnd()
17563 
 
17564 
  def write(self, oprot):
17565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17567 
      return
17568 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
17569 
    if self.ex is not None:
17570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17571 
      self.ex.write(oprot)
17572 
      oprot.writeFieldEnd()
17573 
    oprot.writeFieldStop()
17574 
    oprot.writeStructEnd()
17575 
 
17576 
  def validate(self):
17577 
    return
17578 
 
17579 
 
17580 
  def __repr__(self):
17581 
    L = ['%s=%r' % (key, value)
17582 
      for key, value in self.__dict__.iteritems()]
17583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17584 
 
17585 
  def __eq__(self, other):
17586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17587 
 
17588 
  def __ne__(self, other):
17589 
    return not (self == other)
17590 
 
17591 
class getSettlementForPaymentId_args:
17592 
  """
17593 
  Attributes:
17594 
   - paymentId
17595 
  """
17596 
 
17597 
  thrift_spec = (
17598 
    None, # 0
17599 
    (1, TType.I64, 'paymentId', None, None, ), # 1
17600 
  )
17601 
 
17602 
  def __init__(self, paymentId=None,):
17603 
    self.paymentId = paymentId
17604 
 
17605 
  def read(self, iprot):
17606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17608 
      return
17609 
    iprot.readStructBegin()
17610 
    while True:
17611 
      (fname, ftype, fid) = iprot.readFieldBegin()
17612 
      if ftype == TType.STOP:
17613 
        break
17614 
      if fid == 1:
17615 
        if ftype == TType.I64:
17616 
          self.paymentId = iprot.readI64();
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
17629 
    if self.paymentId is not None:
17630 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
17631 
      oprot.writeI64(self.paymentId)
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
17650 
 
17651 
class getSettlementForPaymentId_result:
17652 
  """
17653 
  Attributes:
17654 
   - success
17655 
   - ex
17656 
  """
17657 
 
17658 
  thrift_spec = (
17659 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
17660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17661 
  )
17662 
 
17663 
  def __init__(self, success=None, ex=None,):
17664 
    self.success = success
17665 
    self.ex = ex
17666 
 
17667 
  def read(self, iprot):
17668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17670 
      return
17671 
    iprot.readStructBegin()
17672 
    while True:
17673 
      (fname, ftype, fid) = iprot.readFieldBegin()
17674 
      if ftype == TType.STOP:
17675 
        break
17676 
      if fid == 0:
17677 
        if ftype == TType.STRUCT:
17678 
          self.success = PaymentSettlement()
17679 
          self.success.read(iprot)
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      elif fid == 1:
17683 
        if ftype == TType.STRUCT:
17684 
          self.ex = TransactionServiceException()
17685 
          self.ex.read(iprot)
17686 
        else:
17687 
          iprot.skip(ftype)
17688 
      else:
17689 
        iprot.skip(ftype)
17690 
      iprot.readFieldEnd()
17691 
    iprot.readStructEnd()
17692 
 
17693 
  def write(self, oprot):
17694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17696 
      return
17697 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
17698 
    if self.success is not None:
17699 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17700 
      self.success.write(oprot)
17701 
      oprot.writeFieldEnd()
17702 
    if self.ex is not None:
17703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17704 
      self.ex.write(oprot)
17705 
      oprot.writeFieldEnd()
17706 
    oprot.writeFieldStop()
17707 
    oprot.writeStructEnd()
17708 
 
17709 
  def validate(self):
17710 
    return
17711 
 
17712 
 
17713 
  def __repr__(self):
17714 
    L = ['%s=%r' % (key, value)
17715 
      for key, value in self.__dict__.iteritems()]
17716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17717 
 
17718 
  def __eq__(self, other):
17719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17720 
 
17721 
  def __ne__(self, other):
17722 
    return not (self == other)
17723 
 
17724 
class getEBSSettlementSummaries_args:
17725 
 
17726 
  thrift_spec = (
17727 
  )
17728 
 
17729 
  def read(self, iprot):
17730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17732 
      return
17733 
    iprot.readStructBegin()
17734 
    while True:
17735 
      (fname, ftype, fid) = iprot.readFieldBegin()
17736 
      if ftype == TType.STOP:
17737 
        break
17738 
      else:
17739 
        iprot.skip(ftype)
17740 
      iprot.readFieldEnd()
17741 
    iprot.readStructEnd()
17742 
 
17743 
  def write(self, oprot):
17744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17746 
      return
17747 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
17748 
    oprot.writeFieldStop()
17749 
    oprot.writeStructEnd()
17750 
 
17751 
  def validate(self):
17752 
    return
17753 
 
17754 
 
17755 
  def __repr__(self):
17756 
    L = ['%s=%r' % (key, value)
17757 
      for key, value in self.__dict__.iteritems()]
17758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17759 
 
17760 
  def __eq__(self, other):
17761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17762 
 
17763 
  def __ne__(self, other):
17764 
    return not (self == other)
17765 
 
17766 
class getEBSSettlementSummaries_result:
17767 
  """
17768 
  Attributes:
17769 
   - success
17770 
   - ex
17771 
  """
17772 
 
17773 
  thrift_spec = (
17774 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
17775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17776 
  )
17777 
 
17778 
  def __init__(self, success=None, ex=None,):
17779 
    self.success = success
17780 
    self.ex = ex
17781 
 
17782 
  def read(self, iprot):
17783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17785 
      return
17786 
    iprot.readStructBegin()
17787 
    while True:
17788 
      (fname, ftype, fid) = iprot.readFieldBegin()
17789 
      if ftype == TType.STOP:
17790 
        break
17791 
      if fid == 0:
17792 
        if ftype == TType.MAP:
17793 
          self.success = {}
17794 
          (_ktype308, _vtype309, _size307 ) = iprot.readMapBegin()
17795 
          for _i311 in xrange(_size307):
17796 
            _key312 = iprot.readI64();
17797 
            _val313 = iprot.readString();
17798 
            self.success[_key312] = _val313
17799 
          iprot.readMapEnd()
17800 
        else:
17801 
          iprot.skip(ftype)
17802 
      elif fid == 1:
17803 
        if ftype == TType.STRUCT:
17804 
          self.ex = TransactionServiceException()
17805 
          self.ex.read(iprot)
17806 
        else:
17807 
          iprot.skip(ftype)
17808 
      else:
17809 
        iprot.skip(ftype)
17810 
      iprot.readFieldEnd()
17811 
    iprot.readStructEnd()
17812 
 
17813 
  def write(self, oprot):
17814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17816 
      return
17817 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
17818 
    if self.success is not None:
17819 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17820 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
17821 
      for kiter314,viter315 in self.success.items():
17822 
        oprot.writeI64(kiter314)
17823 
        oprot.writeString(viter315)
17824 
      oprot.writeMapEnd()
17825 
      oprot.writeFieldEnd()
17826 
    if self.ex is not None:
17827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17828 
      self.ex.write(oprot)
17829 
      oprot.writeFieldEnd()
17830 
    oprot.writeFieldStop()
17831 
    oprot.writeStructEnd()
17832 
 
17833 
  def validate(self):
17834 
    return
17835 
 
17836 
 
17837 
  def __repr__(self):
17838 
    L = ['%s=%r' % (key, value)
17839 
      for key, value in self.__dict__.iteritems()]
17840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17841 
 
17842 
  def __eq__(self, other):
17843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17844 
 
17845 
  def __ne__(self, other):
17846 
    return not (self == other)
17847 
 
17848 
class markEBSSettlementUploaded_args:
17849 
  """
17850 
  Attributes:
17851 
   - settlementId
17852 
  """
17853 
 
17854 
  thrift_spec = (
17855 
    None, # 0
17856 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17857 
  )
17858 
 
17859 
  def __init__(self, settlementId=None,):
17860 
    self.settlementId = settlementId
17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      if fid == 1:
17872 
        if ftype == TType.I64:
17873 
          self.settlementId = iprot.readI64();
17874 
        else:
17875 
          iprot.skip(ftype)
17876 
      else:
17877 
        iprot.skip(ftype)
17878 
      iprot.readFieldEnd()
17879 
    iprot.readStructEnd()
17880 
 
17881 
  def write(self, oprot):
17882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17884 
      return
17885 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
17886 
    if self.settlementId is not None:
17887 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17888 
      oprot.writeI64(self.settlementId)
17889 
      oprot.writeFieldEnd()
17890 
    oprot.writeFieldStop()
17891 
    oprot.writeStructEnd()
17892 
 
17893 
  def validate(self):
17894 
    return
17895 
 
17896 
 
17897 
  def __repr__(self):
17898 
    L = ['%s=%r' % (key, value)
17899 
      for key, value in self.__dict__.iteritems()]
17900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17901 
 
17902 
  def __eq__(self, other):
17903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17904 
 
17905 
  def __ne__(self, other):
17906 
    return not (self == other)
17907 
 
17908 
class markEBSSettlementUploaded_result:
17909 
  """
17910 
  Attributes:
17911 
   - ex
17912 
  """
17913 
 
17914 
  thrift_spec = (
17915 
    None, # 0
17916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17917 
  )
17918 
 
17919 
  def __init__(self, ex=None,):
17920 
    self.ex = ex
17921 
 
17922 
  def read(self, iprot):
17923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17925 
      return
17926 
    iprot.readStructBegin()
17927 
    while True:
17928 
      (fname, ftype, fid) = iprot.readFieldBegin()
17929 
      if ftype == TType.STOP:
17930 
        break
17931 
      if fid == 1:
17932 
        if ftype == TType.STRUCT:
17933 
          self.ex = TransactionServiceException()
17934 
          self.ex.read(iprot)
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      else:
17938 
        iprot.skip(ftype)
17939 
      iprot.readFieldEnd()
17940 
    iprot.readStructEnd()
17941 
 
17942 
  def write(self, oprot):
17943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17945 
      return
17946 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
17947 
    if self.ex is not None:
17948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17949 
      self.ex.write(oprot)
17950 
      oprot.writeFieldEnd()
17951 
    oprot.writeFieldStop()
17952 
    oprot.writeStructEnd()
17953 
 
17954 
  def validate(self):
17955 
    return
17956 
 
17957 
 
17958 
  def __repr__(self):
17959 
    L = ['%s=%r' % (key, value)
17960 
      for key, value in self.__dict__.iteritems()]
17961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17962 
 
17963 
  def __eq__(self, other):
17964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17965 
 
17966 
  def __ne__(self, other):
17967 
    return not (self == other)
17968 
 
17969 
class getEBSSettlementDate_args:
17970 
  """
17971 
  Attributes:
17972 
   - settlementId
17973 
  """
17974 
 
17975 
  thrift_spec = (
17976 
    None, # 0
17977 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17978 
  )
17979 
 
17980 
  def __init__(self, settlementId=None,):
17981 
    self.settlementId = settlementId
17982 
 
17983 
  def read(self, iprot):
17984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17986 
      return
17987 
    iprot.readStructBegin()
17988 
    while True:
17989 
      (fname, ftype, fid) = iprot.readFieldBegin()
17990 
      if ftype == TType.STOP:
17991 
        break
17992 
      if fid == 1:
17993 
        if ftype == TType.I64:
17994 
          self.settlementId = iprot.readI64();
17995 
        else:
17996 
          iprot.skip(ftype)
17997 
      else:
17998 
        iprot.skip(ftype)
17999 
      iprot.readFieldEnd()
18000 
    iprot.readStructEnd()
18001 
 
18002 
  def write(self, oprot):
18003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18005 
      return
18006 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18007 
    if self.settlementId is not None:
18008 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18009 
      oprot.writeI64(self.settlementId)
18010 
      oprot.writeFieldEnd()
18011 
    oprot.writeFieldStop()
18012 
    oprot.writeStructEnd()
18013 
 
18014 
  def validate(self):
18015 
    return
18016 
 
18017 
 
18018 
  def __repr__(self):
18019 
    L = ['%s=%r' % (key, value)
18020 
      for key, value in self.__dict__.iteritems()]
18021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18022 
 
18023 
  def __eq__(self, other):
18024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18025 
 
18026 
  def __ne__(self, other):
18027 
    return not (self == other)
18028 
 
18029 
class getEBSSettlementDate_result:
18030 
  """
18031 
  Attributes:
18032 
   - success
18033 
   - ex
18034 
  """
18035 
 
18036 
  thrift_spec = (
18037 
    (0, TType.I64, 'success', None, None, ), # 0
18038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18039 
  )
18040 
 
18041 
  def __init__(self, success=None, ex=None,):
18042 
    self.success = success
18043 
    self.ex = ex
18044 
 
18045 
  def read(self, iprot):
18046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18048 
      return
18049 
    iprot.readStructBegin()
18050 
    while True:
18051 
      (fname, ftype, fid) = iprot.readFieldBegin()
18052 
      if ftype == TType.STOP:
18053 
        break
18054 
      if fid == 0:
18055 
        if ftype == TType.I64:
18056 
          self.success = iprot.readI64();
18057 
        else:
18058 
          iprot.skip(ftype)
18059 
      elif fid == 1:
18060 
        if ftype == TType.STRUCT:
18061 
          self.ex = TransactionServiceException()
18062 
          self.ex.read(iprot)
18063 
        else:
18064 
          iprot.skip(ftype)
18065 
      else:
18066 
        iprot.skip(ftype)
18067 
      iprot.readFieldEnd()
18068 
    iprot.readStructEnd()
18069 
 
18070 
  def write(self, oprot):
18071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18073 
      return
18074 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18075 
    if self.success is not None:
18076 
      oprot.writeFieldBegin('success', TType.I64, 0)
18077 
      oprot.writeI64(self.success)
18078 
      oprot.writeFieldEnd()
18079 
    if self.ex is not None:
18080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18081 
      self.ex.write(oprot)
18082 
      oprot.writeFieldEnd()
18083 
    oprot.writeFieldStop()
18084 
    oprot.writeStructEnd()
18085 
 
18086 
  def validate(self):
18087 
    return
18088 
 
18089 
 
18090 
  def __repr__(self):
18091 
    L = ['%s=%r' % (key, value)
18092 
      for key, value in self.__dict__.iteritems()]
18093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18094 
 
18095 
  def __eq__(self, other):
18096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18097 
 
18098 
  def __ne__(self, other):
18099 
    return not (self == other)