Subversion Repositories SmartDukaan

Rev

Rev 4586 | Rev 4602 | 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 
 
497 
  def authorizePickup(self, orderId, pickupNumber):
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
509 
    """
510 
    pass
511 
 
2764 chandransh 512 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
513 
    """
514 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
515 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 516 
 
2764 chandransh 517 
    Parameters:
518 
     - providerId
519 
     - pickupDetails
520 
    """
521 
    pass
522 
 
4479 rajveer 523 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 524 
    """
4452 rajveer 525 
    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 526 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 527 
    If the order is in any other state, it returns false.
528 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 529 
 
2591 chandransh 530 
    Parameters:
531 
     - orderId
4479 rajveer 532 
     - receiveCondition
2591 chandransh 533 
    """
534 
    pass
2536 chandransh 535 
 
2591 chandransh 536 
  def validateDoa(self, orderId, isValid):
537 
    """
4452 rajveer 538 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 539 
    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 540 
    If the order is in any other state, it returns false.
541 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 542 
 
2591 chandransh 543 
    Parameters:
544 
     - orderId
545 
     - isValid
546 
    """
547 
    pass
548 
 
4495 rajveer 549 
  def validateReturnProduct(self, orderId, isUsable):
550 
    """
551 
    Parameters:
552 
     - orderId
553 
     - isUsable
554 
    """
555 
    pass
556 
 
2616 chandransh 557 
  def reshipOrder(self, orderId):
558 
    """
4484 rajveer 559 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 560 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 561 
    	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 562 
 
563 
    If the order is in DOA_CERT_VALID state, it does the following:
564 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
565 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 566 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 567 
 
2616 chandransh 568 
    Returns the id of the newly created order.
3431 rajveer 569 
 
2616 chandransh 570 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 571 
 
2616 chandransh 572 
    Parameters:
573 
     - orderId
574 
    """
575 
    pass
2591 chandransh 576 
 
3226 chandransh 577 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 578 
    """
4484 rajveer 579 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 580 
    	1. Creates a refund request for batch processing.
581 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 582 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 583 
 
2616 chandransh 584 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
585 
    	1. Creates a refund request for batch processing.
3226 chandransh 586 
    	2. Cancels the reservation of the item in the warehouse.
587 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 588 
 
3226 chandransh 589 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
590 
    	1. Cancels the reservation of the item in the warehouse.
591 
    	2. Marks the current order as CANCELED.
592 
 
593 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
594 
 
2616 chandransh 595 
    Returns True if it is successful, False otherwise.
3431 rajveer 596 
 
2616 chandransh 597 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 598 
 
2616 chandransh 599 
    Parameters:
600 
     - orderId
3226 chandransh 601 
     - refundedBy
602 
     - reason
2616 chandransh 603 
    """
604 
    pass
605 
 
2690 chandransh 606 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
607 
    """
608 
    Get all return orders created between the from and to dates for the given warehouse.
609 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 610 
 
2690 chandransh 611 
    Parameters:
612 
     - warehouseId
613 
     - fromDate
614 
     - toDate
615 
    """
616 
    pass
2616 chandransh 617 
 
2700 chandransh 618 
  def getReturnOrder(self, id):
619 
    """
620 
    Returns the ReturnOrder corresponding to the given id.
621 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 622 
 
2700 chandransh 623 
    Parameters:
624 
     - id
625 
    """
626 
    pass
627 
 
2690 chandransh 628 
  def processReturn(self, returnOrderId):
629 
    """
630 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 631 
 
2690 chandransh 632 
    Parameters:
633 
     - returnOrderId
634 
    """
635 
    pass
636 
 
2819 chandransh 637 
  def createPurchaseOrder(self, warehouseId):
638 
    """
4586 mandeep.dh 639 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
640 
    Returns the list of PO no. of the newly created purchase order.
641 
    Returns null if no new purchase order had to be created.
3431 rajveer 642 
 
2819 chandransh 643 
    Parameters:
644 
     - warehouseId
645 
    """
646 
    pass
2690 chandransh 647 
 
3451 chandransh 648 
  def updateWeight(self, orderId, weight):
649 
    """
650 
    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 651 
 
3451 chandransh 652 
    Parameters:
653 
     - orderId
654 
     - weight
655 
    """
656 
    pass
657 
 
3469 chandransh 658 
  def changeItem(self, orderId, itemId):
659 
    """
660 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
661 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 662 
 
3469 chandransh 663 
    Parameters:
664 
     - orderId
665 
     - itemId
666 
    """
667 
    pass
668 
 
669 
  def shiftToWarehouse(self, orderId, warehouseId):
670 
    """
671 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
672 
 
673 
    Parameters:
674 
     - orderId
675 
     - warehouseId
676 
    """
677 
    pass
678 
 
3986 chandransh 679 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 680 
    """
681 
    Adds the given delay reason to the given order.
3986 chandransh 682 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 683 
    Raises an exception if no order with the given id can be found.
3469 chandransh 684 
 
3553 chandransh 685 
    Parameters:
686 
     - orderId
687 
     - delayReason
3986 chandransh 688 
     - furtherDelay
3553 chandransh 689 
    """
690 
    pass
691 
 
3956 chandransh 692 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
693 
    """
694 
    Marks the COD orders with given AWB nos. as having been processed.
695 
    Updates the captured amount for the corresponding payment.
3553 chandransh 696 
 
3956 chandransh 697 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
698 
    1. There is no order corresponding to an AWB number.
699 
    2. The captured amount for a payment exceeds the total payment.
700 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
701 
 
702 
    Parameters:
703 
     - collectedAmountMap
704 
     - xferBy
705 
     - xferTxnId
706 
     - xferDate
707 
    """
708 
    pass
709 
 
4008 mandeep.dh 710 
  def getTransactionsRequiringExtraProcessing(self, category):
711 
    """
4065 mandeep.dh 712 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 713 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 714 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 715 
 
4008 mandeep.dh 716 
    Parameters:
717 
     - category
718 
    """
719 
    pass
720 
 
721 
  def markTransactionAsProcessed(self, transactionId, category):
722 
    """
723 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 724 
    It essentially deletes the transaction id record for a particular
725 
    processing type category (if present) from DB.
726 
    This is currently used by CRM application.
4008 mandeep.dh 727 
 
728 
    Parameters:
729 
     - transactionId
730 
     - category
731 
    """
732 
    pass
733 
 
4018 chandransh 734 
  def getItemWiseRiskyOrdersCount(self, ):
735 
    """
736 
    Returns a map containing the number of risky orders keyed by item id. A risky order
737 
    is defined as one whose shipping date is about to expire.
738 
    """
739 
    pass
4008 mandeep.dh 740 
 
4295 varun.gupt 741 
  def getOrdersForItemIds(self, itemIds):
742 
    """
743 
    Returns a list of all orders which have items with given id
744 
 
745 
    Parameters:
746 
     - itemIds
747 
    """
748 
    pass
749 
 
4247 rajveer 750 
  def markOrderCancellationRequestReceived(self, orderId):
751 
    """
752 
    Mark order as cancellation request received. If customer sends request of cancellation of
753 
    a particular order, this method will be called. It will just change status of the order
754 
    depending on its current status. It also records the previous status, so that we can move
755 
    back to that status if cancellation request is denied.
4018 chandransh 756 
 
4247 rajveer 757 
    Parameters:
758 
     - orderId
759 
    """
760 
    pass
761 
 
762 
  def markOrderCancellationRequestConfirmed(self, orderId):
763 
    """
764 
    If we decide to to cancel order, CRM will call this method to move the status of order to
765 
    cancellation request confirmed. After this OM will be able to cancel the order.
766 
 
767 
    Parameters:
768 
     - orderId
769 
    """
770 
    pass
771 
 
772 
  def markOrderCancellationRequestDenied(self, orderId):
773 
    """
774 
    If we decide to not to cancel order, we will move the order ro previous status.
775 
 
776 
    Parameters:
777 
     - orderId
778 
    """
779 
    pass
780 
 
4258 rajveer 781 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 782 
    """
4258 rajveer 783 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
784 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 785 
 
786 
    Parameters:
4258 rajveer 787 
     - transactionId
4247 rajveer 788 
    """
789 
    pass
790 
 
4259 anupam.sin 791 
  def refundTransaction(self, transactionId, refundedBy, reason):
792 
    """
793 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
794 
    need to be cancelled
4247 rajveer 795 
 
4259 anupam.sin 796 
    Parameters:
797 
     - transactionId
798 
     - refundedBy
799 
     - reason
800 
    """
801 
    pass
802 
 
4324 mandeep.dh 803 
  def updateShipmentAddress(self, orderId, addressId):
804 
    """
805 
    Updates shipment address of an order. Delivery and shipping date estimates
806 
    etc. are also updated here.
807 
 
808 
    Throws TransactionServiceException in case address change is not
809 
    possible due to certain reasons such as new pincode in address is
810 
    not serviceable etc.
811 
 
812 
    Parameters:
813 
     - orderId
814 
     - addressId
815 
    """
816 
    pass
817 
 
4285 rajveer 818 
  def acceptOrdersForItemId(self, itemId, inventory):
819 
    """
820 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
821 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 822 
 
4285 rajveer 823 
    Parameters:
824 
     - itemId
825 
     - inventory
826 
    """
827 
    pass
828 
 
4369 rajveer 829 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 830 
    """
831 
    Parameters:
832 
     - vendorId
833 
     - itemId
834 
     - quantity
835 
     - estimate
4369 rajveer 836 
     - isReminder
4303 rajveer 837 
    """
838 
    pass
4285 rajveer 839 
 
4369 rajveer 840 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 841 
    """
842 
    Parameters:
843 
     - vendorId
844 
     - itemId
845 
     - quantity
846 
     - estimate
4369 rajveer 847 
     - isReminder
4303 rajveer 848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
861 
 
4369 rajveer 862 
  def markOrdersAsTimeout(self, vendorId):
863 
    """
864 
    Parameters:
865 
     - vendorId
866 
    """
867 
    pass
4303 rajveer 868 
 
4386 anupam.sin 869 
  def getOrderForAwb(self, awb):
870 
    """
871 
    Returns the order corresponding to an AWB number
4369 rajveer 872 
 
4386 anupam.sin 873 
    Parameters:
874 
     - awb
875 
    """
876 
    pass
877 
 
4506 phani.kuma 878 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
879 
    """
880 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 881 
 
4506 phani.kuma 882 
    Parameters:
883 
     - logistics_provider_id
884 
     - order_status
885 
    """
886 
    pass
887 
 
4600 varun.gupt 888 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
889 
    """
890 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 891 
 
4600 varun.gupt 892 
    Parameters:
893 
     - vendorId
894 
     - billingDateFrom
895 
     - billingDateTo
896 
    """
897 
    pass
898 
 
899 
  def saveBluedartSettlements(self, mapAWBAndAmount):
900 
    """
901 
    Parameters:
902 
     - mapAWBAndAmount
903 
    """
904 
    pass
905 
 
906 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
907 
    """
908 
    Parameters:
909 
     - settlementDate
910 
     - paymentGatewayId
911 
     - paymentId
912 
     - serviceTax
913 
     - otherCharges
914 
     - netCollection
915 
    """
916 
    pass
917 
 
918 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
919 
    """
920 
    Parameters:
921 
     - settlementId
922 
     - settlementDate
923 
     - transactionDateFrom
924 
     - transactionDateTo
925 
     - amount
926 
    """
927 
    pass
928 
 
929 
  def getSettlementForPaymentId(self, paymentId):
930 
    """
931 
    Parameters:
932 
     - paymentId
933 
    """
934 
    pass
935 
 
936 
  def getEBSSettlementSummaries(self, ):
937 
    pass
938 
 
939 
  def markEBSSettlementUploaded(self, settlementId):
940 
    """
941 
    Parameters:
942 
     - settlementId
943 
    """
944 
    pass
945 
 
946 
  def getEBSSettlementDate(self, settlementId):
947 
    """
948 
    Parameters:
949 
     - settlementId
950 
    """
951 
    pass
952 
 
953 
 
3376 rajveer 954 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 955 
  def __init__(self, iprot, oprot=None):
3376 rajveer 956 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 957 
 
958 
  def createTransaction(self, transaction):
959 
    """
960 
    Parameters:
961 
     - transaction
962 
    """
963 
    self.send_createTransaction(transaction)
132 ashish 964 
    return self.recv_createTransaction()
94 ashish 965 
 
966 
  def send_createTransaction(self, transaction):
967 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
968 
    args = createTransaction_args()
969 
    args.transaction = transaction
970 
    args.write(self._oprot)
971 
    self._oprot.writeMessageEnd()
972 
    self._oprot.trans.flush()
973 
 
974 
  def recv_createTransaction(self, ):
975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
976 
    if mtype == TMessageType.EXCEPTION:
977 
      x = TApplicationException()
978 
      x.read(self._iprot)
979 
      self._iprot.readMessageEnd()
980 
      raise x
981 
    result = createTransaction_result()
982 
    result.read(self._iprot)
983 
    self._iprot.readMessageEnd()
3431 rajveer 984 
    if result.success is not None:
132 ashish 985 
      return result.success
3431 rajveer 986 
    if result.ex is not None:
94 ashish 987 
      raise result.ex
132 ashish 988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 989 
 
990 
  def getTransaction(self, id):
991 
    """
992 
    Parameters:
993 
     - id
994 
    """
995 
    self.send_getTransaction(id)
996 
    return self.recv_getTransaction()
997 
 
998 
  def send_getTransaction(self, id):
999 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1000 
    args = getTransaction_args()
1001 
    args.id = id
1002 
    args.write(self._oprot)
1003 
    self._oprot.writeMessageEnd()
1004 
    self._oprot.trans.flush()
1005 
 
1006 
  def recv_getTransaction(self, ):
1007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1008 
    if mtype == TMessageType.EXCEPTION:
1009 
      x = TApplicationException()
1010 
      x.read(self._iprot)
1011 
      self._iprot.readMessageEnd()
1012 
      raise x
1013 
    result = getTransaction_result()
1014 
    result.read(self._iprot)
1015 
    self._iprot.readMessageEnd()
3431 rajveer 1016 
    if result.success is not None:
94 ashish 1017 
      return result.success
3431 rajveer 1018 
    if result.ex is not None:
94 ashish 1019 
      raise result.ex
1020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1021 
 
1022 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1023 
    """
1024 
    Parameters:
1025 
     - customerId
1026 
     - from_date
1027 
     - to_date
1028 
     - status
1029 
    """
1030 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1031 
    return self.recv_getTransactionsForCustomer()
1032 
 
1033 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1034 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1035 
    args = getTransactionsForCustomer_args()
1036 
    args.customerId = customerId
1037 
    args.from_date = from_date
1038 
    args.to_date = to_date
1039 
    args.status = status
1040 
    args.write(self._oprot)
1041 
    self._oprot.writeMessageEnd()
1042 
    self._oprot.trans.flush()
1043 
 
1044 
  def recv_getTransactionsForCustomer(self, ):
1045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1046 
    if mtype == TMessageType.EXCEPTION:
1047 
      x = TApplicationException()
1048 
      x.read(self._iprot)
1049 
      self._iprot.readMessageEnd()
1050 
      raise x
1051 
    result = getTransactionsForCustomer_result()
1052 
    result.read(self._iprot)
1053 
    self._iprot.readMessageEnd()
3431 rajveer 1054 
    if result.success is not None:
94 ashish 1055 
      return result.success
3431 rajveer 1056 
    if result.ex is not None:
94 ashish 1057 
      raise result.ex
1058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1059 
 
132 ashish 1060 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1061 
    """
1062 
    Parameters:
1063 
     - shoppingCartId
1064 
    """
1065 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1066 
    return self.recv_getTransactionsForShoppingCartId()
1067 
 
1068 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1069 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1070 
    args = getTransactionsForShoppingCartId_args()
1071 
    args.shoppingCartId = shoppingCartId
1072 
    args.write(self._oprot)
1073 
    self._oprot.writeMessageEnd()
1074 
    self._oprot.trans.flush()
1075 
 
1076 
  def recv_getTransactionsForShoppingCartId(self, ):
1077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1078 
    if mtype == TMessageType.EXCEPTION:
1079 
      x = TApplicationException()
1080 
      x.read(self._iprot)
1081 
      self._iprot.readMessageEnd()
1082 
      raise x
1083 
    result = getTransactionsForShoppingCartId_result()
1084 
    result.read(self._iprot)
1085 
    self._iprot.readMessageEnd()
3431 rajveer 1086 
    if result.success is not None:
132 ashish 1087 
      return result.success
3431 rajveer 1088 
    if result.ex is not None:
132 ashish 1089 
      raise result.ex
1090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1091 
 
94 ashish 1092 
  def getTransactionStatus(self, transactionId):
1093 
    """
1094 
    Parameters:
1095 
     - transactionId
1096 
    """
1097 
    self.send_getTransactionStatus(transactionId)
1098 
    return self.recv_getTransactionStatus()
1099 
 
1100 
  def send_getTransactionStatus(self, transactionId):
1101 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1102 
    args = getTransactionStatus_args()
1103 
    args.transactionId = transactionId
1104 
    args.write(self._oprot)
1105 
    self._oprot.writeMessageEnd()
1106 
    self._oprot.trans.flush()
1107 
 
1108 
  def recv_getTransactionStatus(self, ):
1109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1110 
    if mtype == TMessageType.EXCEPTION:
1111 
      x = TApplicationException()
1112 
      x.read(self._iprot)
1113 
      self._iprot.readMessageEnd()
1114 
      raise x
1115 
    result = getTransactionStatus_result()
1116 
    result.read(self._iprot)
1117 
    self._iprot.readMessageEnd()
3431 rajveer 1118 
    if result.success is not None:
94 ashish 1119 
      return result.success
3431 rajveer 1120 
    if result.ex is not None:
94 ashish 1121 
      raise result.ex
1122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1123 
 
1124 
  def changeTransactionStatus(self, transactionId, status, description):
1125 
    """
1126 
    Parameters:
1127 
     - transactionId
1128 
     - status
1129 
     - description
1130 
    """
1131 
    self.send_changeTransactionStatus(transactionId, status, description)
1132 
    return self.recv_changeTransactionStatus()
1133 
 
1134 
  def send_changeTransactionStatus(self, transactionId, status, description):
1135 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1136 
    args = changeTransactionStatus_args()
1137 
    args.transactionId = transactionId
1138 
    args.status = status
1139 
    args.description = description
1140 
    args.write(self._oprot)
1141 
    self._oprot.writeMessageEnd()
1142 
    self._oprot.trans.flush()
1143 
 
1144 
  def recv_changeTransactionStatus(self, ):
1145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1146 
    if mtype == TMessageType.EXCEPTION:
1147 
      x = TApplicationException()
1148 
      x.read(self._iprot)
1149 
      self._iprot.readMessageEnd()
1150 
      raise x
1151 
    result = changeTransactionStatus_result()
1152 
    result.read(self._iprot)
1153 
    self._iprot.readMessageEnd()
3431 rajveer 1154 
    if result.success is not None:
94 ashish 1155 
      return result.success
3431 rajveer 1156 
    if result.ex is not None:
94 ashish 1157 
      raise result.ex
1158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1159 
 
1398 varun.gupt 1160 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1161 
    """
1162 
    Parameters:
1163 
     - transactionId
1164 
    """
1398 varun.gupt 1165 
    self.send_enqueueTransactionInfoEmail(transactionId)
1166 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1167 
 
1398 varun.gupt 1168 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1169 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1170 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1171 
    args.transactionId = transactionId
1172 
    args.write(self._oprot)
1173 
    self._oprot.writeMessageEnd()
1174 
    self._oprot.trans.flush()
1175 
 
1398 varun.gupt 1176 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1178 
    if mtype == TMessageType.EXCEPTION:
1179 
      x = TApplicationException()
1180 
      x.read(self._iprot)
1181 
      self._iprot.readMessageEnd()
1182 
      raise x
1398 varun.gupt 1183 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1184 
    result.read(self._iprot)
1185 
    self._iprot.readMessageEnd()
3431 rajveer 1186 
    if result.success is not None:
1382 varun.gupt 1187 
      return result.success
3431 rajveer 1188 
    if result.ex is not None:
1382 varun.gupt 1189 
      raise result.ex
1398 varun.gupt 1190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1191 
 
483 rajveer 1192 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1193 
    """
1194 
    Parameters:
483 rajveer 1195 
     - status
1196 
     - from_date
1197 
     - to_date
1198 
     - warehouse_id
94 ashish 1199 
    """
483 rajveer 1200 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1201 
    return self.recv_getAllOrders()
94 ashish 1202 
 
483 rajveer 1203 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1204 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1205 
    args = getAllOrders_args()
1206 
    args.status = status
1207 
    args.from_date = from_date
1208 
    args.to_date = to_date
1209 
    args.warehouse_id = warehouse_id
94 ashish 1210 
    args.write(self._oprot)
1211 
    self._oprot.writeMessageEnd()
1212 
    self._oprot.trans.flush()
1213 
 
483 rajveer 1214 
  def recv_getAllOrders(self, ):
94 ashish 1215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1216 
    if mtype == TMessageType.EXCEPTION:
1217 
      x = TApplicationException()
1218 
      x.read(self._iprot)
1219 
      self._iprot.readMessageEnd()
1220 
      raise x
483 rajveer 1221 
    result = getAllOrders_result()
94 ashish 1222 
    result.read(self._iprot)
1223 
    self._iprot.readMessageEnd()
3431 rajveer 1224 
    if result.success is not None:
94 ashish 1225 
      return result.success
3431 rajveer 1226 
    if result.ex is not None:
94 ashish 1227 
      raise result.ex
483 rajveer 1228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1229 
 
4133 chandransh 1230 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1231 
    """
1232 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1233 
    Pass the status as null and the limit as 0 to ignore them.
1234 
 
1235 
    Parameters:
1236 
     - statuses
1237 
     - offset
1238 
     - limit
1239 
     - warehouse_id
1240 
    """
1241 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1242 
    return self.recv_getOrdersInBatch()
1243 
 
1244 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1245 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1246 
    args = getOrdersInBatch_args()
1247 
    args.statuses = statuses
1248 
    args.offset = offset
1249 
    args.limit = limit
1250 
    args.warehouse_id = warehouse_id
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getOrdersInBatch(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getOrdersInBatch_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
1265 
    if result.success is not None:
1266 
      return result.success
1267 
    if result.ex is not None:
1268 
      raise result.ex
1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1270 
 
1271 
  def getOrderCount(self, statuses, warehouseId):
1272 
    """
1273 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1274 
 
1275 
    Parameters:
1276 
     - statuses
1277 
     - warehouseId
1278 
    """
1279 
    self.send_getOrderCount(statuses, warehouseId)
1280 
    return self.recv_getOrderCount()
1281 
 
1282 
  def send_getOrderCount(self, statuses, warehouseId):
1283 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1284 
    args = getOrderCount_args()
1285 
    args.statuses = statuses
1286 
    args.warehouseId = warehouseId
1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_getOrderCount(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = getOrderCount_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
1301 
    if result.success is not None:
1302 
      return result.success
1303 
    if result.ex is not None:
1304 
      raise result.ex
1305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1306 
 
999 varun.gupt 1307 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1308 
    """
1132 chandransh 1309 
    Returns orders within a range of their billing dates
3431 rajveer 1310 
 
999 varun.gupt 1311 
    Parameters:
1312 
     - status
1313 
     - start_billing_date
1314 
     - end_billing_date
1315 
     - warehouse_id
1316 
    """
1317 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1318 
    return self.recv_getOrdersByBillingDate()
1319 
 
1320 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1321 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1322 
    args = getOrdersByBillingDate_args()
1323 
    args.status = status
1324 
    args.start_billing_date = start_billing_date
1325 
    args.end_billing_date = end_billing_date
1326 
    args.warehouse_id = warehouse_id
1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
1331 
  def recv_getOrdersByBillingDate(self, ):
1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
1338 
    result = getOrdersByBillingDate_result()
1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
3431 rajveer 1341 
    if result.success is not None:
999 varun.gupt 1342 
      return result.success
3431 rajveer 1343 
    if result.ex is not None:
999 varun.gupt 1344 
      raise result.ex
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1346 
 
3451 chandransh 1347 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1348 
    """
1349 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1350 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1351 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1352 
 
3427 chandransh 1353 
    Parameters:
1354 
     - fromShippingDate
1355 
     - toShippingDate
1356 
     - providerId
1357 
     - warehouseId
3451 chandransh 1358 
     - cod
3427 chandransh 1359 
    """
3451 chandransh 1360 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1361 
    return self.recv_getOrdersByShippingDate()
1362 
 
3451 chandransh 1363 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1364 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1365 
    args = getOrdersByShippingDate_args()
1366 
    args.fromShippingDate = fromShippingDate
1367 
    args.toShippingDate = toShippingDate
1368 
    args.providerId = providerId
1369 
    args.warehouseId = warehouseId
3451 chandransh 1370 
    args.cod = cod
3427 chandransh 1371 
    args.write(self._oprot)
1372 
    self._oprot.writeMessageEnd()
1373 
    self._oprot.trans.flush()
1374 
 
1375 
  def recv_getOrdersByShippingDate(self, ):
1376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1377 
    if mtype == TMessageType.EXCEPTION:
1378 
      x = TApplicationException()
1379 
      x.read(self._iprot)
1380 
      self._iprot.readMessageEnd()
1381 
      raise x
1382 
    result = getOrdersByShippingDate_result()
1383 
    result.read(self._iprot)
1384 
    self._iprot.readMessageEnd()
3431 rajveer 1385 
    if result.success is not None:
3427 chandransh 1386 
      return result.success
3431 rajveer 1387 
    if result.ex is not None:
3427 chandransh 1388 
      raise result.ex
1389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1390 
 
1382 varun.gupt 1391 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1392 
    """
1393 
    Returns order ids for orders which can be returned
3431 rajveer 1394 
 
1382 varun.gupt 1395 
    Parameters:
1396 
     - customer_id
1397 
     - limit
1398 
    """
1399 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1400 
    return self.recv_getReturnableOrdersForCustomer()
1401 
 
1402 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1403 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1404 
    args = getReturnableOrdersForCustomer_args()
1405 
    args.customer_id = customer_id
1406 
    args.limit = limit
1407 
    args.write(self._oprot)
1408 
    self._oprot.writeMessageEnd()
1409 
    self._oprot.trans.flush()
1410 
 
1411 
  def recv_getReturnableOrdersForCustomer(self, ):
1412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1413 
    if mtype == TMessageType.EXCEPTION:
1414 
      x = TApplicationException()
1415 
      x.read(self._iprot)
1416 
      self._iprot.readMessageEnd()
1417 
      raise x
1418 
    result = getReturnableOrdersForCustomer_result()
1419 
    result.read(self._iprot)
1420 
    self._iprot.readMessageEnd()
3431 rajveer 1421 
    if result.success is not None:
1382 varun.gupt 1422 
      return result.success
3431 rajveer 1423 
    if result.ex is not None:
1382 varun.gupt 1424 
      raise result.ex
1425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1426 
 
1427 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1428 
    """
1429 
    Returns order ids for orders which can be cancelled
3431 rajveer 1430 
 
1382 varun.gupt 1431 
    Parameters:
1432 
     - customer_id
1433 
     - limit
1434 
    """
1435 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1436 
    return self.recv_getCancellableOrdersForCustomer()
1437 
 
1438 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1439 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1440 
    args = getCancellableOrdersForCustomer_args()
1441 
    args.customer_id = customer_id
1442 
    args.limit = limit
1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getCancellableOrdersForCustomer(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getCancellableOrdersForCustomer_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
1382 varun.gupt 1458 
      return result.success
3431 rajveer 1459 
    if result.ex is not None:
1382 varun.gupt 1460 
      raise result.ex
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1462 
 
483 rajveer 1463 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1464 
    """
1465 
    Parameters:
483 rajveer 1466 
     - orderId
1467 
     - status
1468 
     - description
94 ashish 1469 
    """
483 rajveer 1470 
    self.send_changeOrderStatus(orderId, status, description)
1471 
    return self.recv_changeOrderStatus()
94 ashish 1472 
 
483 rajveer 1473 
  def send_changeOrderStatus(self, orderId, status, description):
1474 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1475 
    args = changeOrderStatus_args()
1476 
    args.orderId = orderId
1477 
    args.status = status
1478 
    args.description = description
94 ashish 1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
483 rajveer 1483 
  def recv_changeOrderStatus(self, ):
94 ashish 1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
483 rajveer 1490 
    result = changeOrderStatus_result()
94 ashish 1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
3431 rajveer 1493 
    if result.success is not None:
94 ashish 1494 
      return result.success
3431 rajveer 1495 
    if result.ex is not None:
94 ashish 1496 
      raise result.ex
483 rajveer 1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1498 
 
1528 ankur.sing 1499 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1500 
    """
1528 ankur.sing 1501 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1502 
    only user who owns the transaction can view its order details.
3431 rajveer 1503 
 
94 ashish 1504 
    Parameters:
1505 
     - transactionId
1528 ankur.sing 1506 
     - customerId
94 ashish 1507 
    """
1528 ankur.sing 1508 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1509 
    return self.recv_getOrdersForTransaction()
94 ashish 1510 
 
1528 ankur.sing 1511 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1512 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1513 
    args = getOrdersForTransaction_args()
94 ashish 1514 
    args.transactionId = transactionId
1528 ankur.sing 1515 
    args.customerId = customerId
94 ashish 1516 
    args.write(self._oprot)
1517 
    self._oprot.writeMessageEnd()
1518 
    self._oprot.trans.flush()
1519 
 
483 rajveer 1520 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1522 
    if mtype == TMessageType.EXCEPTION:
1523 
      x = TApplicationException()
1524 
      x.read(self._iprot)
1525 
      self._iprot.readMessageEnd()
1526 
      raise x
483 rajveer 1527 
    result = getOrdersForTransaction_result()
94 ashish 1528 
    result.read(self._iprot)
1529 
    self._iprot.readMessageEnd()
3431 rajveer 1530 
    if result.success is not None:
94 ashish 1531 
      return result.success
3431 rajveer 1532 
    if result.ex is not None:
94 ashish 1533 
      raise result.ex
483 rajveer 1534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1535 
 
3014 chandransh 1536 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1537 
    """
3014 chandransh 1538 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1539 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1540 
 
94 ashish 1541 
    Parameters:
483 rajveer 1542 
     - customerId
1543 
     - from_date
1544 
     - to_date
3014 chandransh 1545 
     - statuses
94 ashish 1546 
    """
3014 chandransh 1547 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1548 
    return self.recv_getOrdersForCustomer()
94 ashish 1549 
 
3014 chandransh 1550 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1551 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1552 
    args = getOrdersForCustomer_args()
1553 
    args.customerId = customerId
1554 
    args.from_date = from_date
1555 
    args.to_date = to_date
3014 chandransh 1556 
    args.statuses = statuses
94 ashish 1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
483 rajveer 1561 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
483 rajveer 1568 
    result = getOrdersForCustomer_result()
94 ashish 1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
3431 rajveer 1571 
    if result.success is not None:
94 ashish 1572 
      return result.success
3431 rajveer 1573 
    if result.ex is not None:
94 ashish 1574 
      raise result.ex
483 rajveer 1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1576 
 
483 rajveer 1577 
  def createOrder(self, order):
94 ashish 1578 
    """
1579 
    Parameters:
483 rajveer 1580 
     - order
94 ashish 1581 
    """
483 rajveer 1582 
    self.send_createOrder(order)
1583 
    return self.recv_createOrder()
94 ashish 1584 
 
483 rajveer 1585 
  def send_createOrder(self, order):
1586 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1587 
    args = createOrder_args()
1588 
    args.order = order
94 ashish 1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
483 rajveer 1593 
  def recv_createOrder(self, ):
94 ashish 1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
483 rajveer 1600 
    result = createOrder_result()
94 ashish 1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
3431 rajveer 1603 
    if result.success is not None:
94 ashish 1604 
      return result.success
3431 rajveer 1605 
    if result.ex is not None:
94 ashish 1606 
      raise result.ex
483 rajveer 1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1608 
 
483 rajveer 1609 
  def getOrder(self, id):
94 ashish 1610 
    """
1611 
    Parameters:
483 rajveer 1612 
     - id
94 ashish 1613 
    """
483 rajveer 1614 
    self.send_getOrder(id)
1615 
    return self.recv_getOrder()
94 ashish 1616 
 
483 rajveer 1617 
  def send_getOrder(self, id):
1618 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1619 
    args = getOrder_args()
1620 
    args.id = id
94 ashish 1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
483 rajveer 1625 
  def recv_getOrder(self, ):
94 ashish 1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
483 rajveer 1632 
    result = getOrder_result()
94 ashish 1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
3431 rajveer 1635 
    if result.success is not None:
94 ashish 1636 
      return result.success
3431 rajveer 1637 
    if result.ex is not None:
94 ashish 1638 
      raise result.ex
483 rajveer 1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1640 
 
483 rajveer 1641 
  def getLineItemsForOrder(self, orderId):
94 ashish 1642 
    """
1643 
    Parameters:
483 rajveer 1644 
     - orderId
94 ashish 1645 
    """
483 rajveer 1646 
    self.send_getLineItemsForOrder(orderId)
1647 
    return self.recv_getLineItemsForOrder()
94 ashish 1648 
 
483 rajveer 1649 
  def send_getLineItemsForOrder(self, orderId):
1650 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1651 
    args = getLineItemsForOrder_args()
1652 
    args.orderId = orderId
94 ashish 1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
483 rajveer 1657 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
483 rajveer 1664 
    result = getLineItemsForOrder_result()
94 ashish 1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
3431 rajveer 1667 
    if result.success is not None:
94 ashish 1668 
      return result.success
3431 rajveer 1669 
    if result.ex is not None:
94 ashish 1670 
      raise result.ex
483 rajveer 1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1672 
 
1528 ankur.sing 1673 
  def getOrderForCustomer(self, orderId, customerId):
1674 
    """
1675 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1676 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1677 
 
1528 ankur.sing 1678 
    Parameters:
1679 
     - orderId
1680 
     - customerId
1681 
    """
1682 
    self.send_getOrderForCustomer(orderId, customerId)
1683 
    return self.recv_getOrderForCustomer()
1684 
 
1685 
  def send_getOrderForCustomer(self, orderId, customerId):
1686 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1687 
    args = getOrderForCustomer_args()
1688 
    args.orderId = orderId
1689 
    args.customerId = customerId
1690 
    args.write(self._oprot)
1691 
    self._oprot.writeMessageEnd()
1692 
    self._oprot.trans.flush()
1693 
 
1694 
  def recv_getOrderForCustomer(self, ):
1695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1696 
    if mtype == TMessageType.EXCEPTION:
1697 
      x = TApplicationException()
1698 
      x.read(self._iprot)
1699 
      self._iprot.readMessageEnd()
1700 
      raise x
1701 
    result = getOrderForCustomer_result()
1702 
    result.read(self._iprot)
1703 
    self._iprot.readMessageEnd()
3431 rajveer 1704 
    if result.success is not None:
1528 ankur.sing 1705 
      return result.success
3431 rajveer 1706 
    if result.ex is not None:
1528 ankur.sing 1707 
      raise result.ex
1708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1709 
 
4444 rajveer 1710 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1711 
    """
1712 
    Parameters:
4394 rajveer 1713 
     - type
4444 rajveer 1714 
     - warehouseId
4394 rajveer 1715 
     - status
1716 
     - timestamp
3064 chandransh 1717 
    """
4444 rajveer 1718 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1719 
    return self.recv_getAlerts()
1720 
 
4444 rajveer 1721 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1722 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1723 
    args = getAlerts_args()
4394 rajveer 1724 
    args.type = type
4444 rajveer 1725 
    args.warehouseId = warehouseId
4394 rajveer 1726 
    args.status = status
1727 
    args.timestamp = timestamp
3064 chandransh 1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getAlerts(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getAlerts_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
3064 chandransh 1743 
      return result.success
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1745 
 
4444 rajveer 1746 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1747 
    """
1748 
    Parameters:
1749 
     - type
4444 rajveer 1750 
     - warehouseId
4394 rajveer 1751 
     - description
3064 chandransh 1752 
    """
4444 rajveer 1753 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1754 
    self.recv_addAlert()
3064 chandransh 1755 
 
4444 rajveer 1756 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1757 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1758 
    args = addAlert_args()
3064 chandransh 1759 
    args.type = type
4444 rajveer 1760 
    args.warehouseId = warehouseId
4394 rajveer 1761 
    args.description = description
3064 chandransh 1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
4394 rajveer 1766 
  def recv_addAlert(self, ):
3064 chandransh 1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
4394 rajveer 1773 
    result = addAlert_result()
3064 chandransh 1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
1776 
    return
1777 
 
4444 rajveer 1778 
  def markAlertsAsSeen(self, warehouseId):
1779 
    """
1780 
    Parameters:
1781 
     - warehouseId
1782 
    """
1783 
    self.send_markAlertsAsSeen(warehouseId)
1784 
    self.recv_markAlertsAsSeen()
1785 
 
1786 
  def send_markAlertsAsSeen(self, warehouseId):
1787 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1788 
    args = markAlertsAsSeen_args()
1789 
    args.warehouseId = warehouseId
1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
1794 
  def recv_markAlertsAsSeen(self, ):
1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
1801 
    result = markAlertsAsSeen_result()
1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
1804 
    return
1805 
 
3064 chandransh 1806 
  def getValidOrderCount(self, ):
1807 
    """
1808 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1809 
    """
1810 
    self.send_getValidOrderCount()
1811 
    return self.recv_getValidOrderCount()
1812 
 
1813 
  def send_getValidOrderCount(self, ):
1814 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1815 
    args = getValidOrderCount_args()
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getValidOrderCount(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getValidOrderCount_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
3064 chandransh 1831 
      return result.success
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1833 
 
1834 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1835 
    """
1836 
    Returns the number of distinct customers who have done successful transactions
1837 
    """
1838 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1839 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1840 
 
1841 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1842 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1843 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
3431 rajveer 1858 
    if result.success is not None:
3064 chandransh 1859 
      return result.success
1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1861 
 
1862 
  def getValidOrdersAmountRange(self, ):
1863 
    """
1864 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1865 
    List contains two values, first minimum amount and second maximum amount.
1866 
    """
1867 
    self.send_getValidOrdersAmountRange()
1868 
    return self.recv_getValidOrdersAmountRange()
1869 
 
1870 
  def send_getValidOrdersAmountRange(self, ):
1871 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1872 
    args = getValidOrdersAmountRange_args()
1873 
    args.write(self._oprot)
1874 
    self._oprot.writeMessageEnd()
1875 
    self._oprot.trans.flush()
1876 
 
1877 
  def recv_getValidOrdersAmountRange(self, ):
1878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1879 
    if mtype == TMessageType.EXCEPTION:
1880 
      x = TApplicationException()
1881 
      x.read(self._iprot)
1882 
      self._iprot.readMessageEnd()
1883 
      raise x
1884 
    result = getValidOrdersAmountRange_result()
1885 
    result.read(self._iprot)
1886 
    self._iprot.readMessageEnd()
3431 rajveer 1887 
    if result.success is not None:
3064 chandransh 1888 
      return result.success
1889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1890 
 
1891 
  def getValidOrders(self, limit):
1892 
    """
1893 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1894 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1895 
 
3064 chandransh 1896 
    Parameters:
1897 
     - limit
1898 
    """
1899 
    self.send_getValidOrders(limit)
1900 
    return self.recv_getValidOrders()
1901 
 
1902 
  def send_getValidOrders(self, limit):
1903 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1904 
    args = getValidOrders_args()
1905 
    args.limit = limit
1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
1910 
  def recv_getValidOrders(self, ):
1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
1917 
    result = getValidOrders_result()
1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
3431 rajveer 1920 
    if result.success is not None:
3064 chandransh 1921 
      return result.success
1922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1923 
 
1220 chandransh 1924 
  def batchOrders(self, warehouseId):
1925 
    """
1926 
    Create a batch of all the pending orders for the given warehouse.
1927 
    The returned list is orderd by created_timestamp.
1928 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1929 
 
1220 chandransh 1930 
    Parameters:
1931 
     - warehouseId
1932 
    """
1933 
    self.send_batchOrders(warehouseId)
1934 
    return self.recv_batchOrders()
1935 
 
1936 
  def send_batchOrders(self, warehouseId):
1937 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1938 
    args = batchOrders_args()
1939 
    args.warehouseId = warehouseId
1940 
    args.write(self._oprot)
1941 
    self._oprot.writeMessageEnd()
1942 
    self._oprot.trans.flush()
1943 
 
1944 
  def recv_batchOrders(self, ):
1945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1946 
    if mtype == TMessageType.EXCEPTION:
1947 
      x = TApplicationException()
1948 
      x.read(self._iprot)
1949 
      self._iprot.readMessageEnd()
1950 
      raise x
1951 
    result = batchOrders_result()
1952 
    result.read(self._iprot)
1953 
    self._iprot.readMessageEnd()
3431 rajveer 1954 
    if result.success is not None:
1220 chandransh 1955 
      return result.success
3431 rajveer 1956 
    if result.ex is not None:
1220 chandransh 1957 
      raise result.ex
1958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1959 
 
1208 chandransh 1960 
  def markOrderAsOutOfStock(self, orderId):
1961 
    """
1962 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1963 
 
1208 chandransh 1964 
    Parameters:
1965 
     - orderId
1966 
    """
1967 
    self.send_markOrderAsOutOfStock(orderId)
1968 
    return self.recv_markOrderAsOutOfStock()
1969 
 
1970 
  def send_markOrderAsOutOfStock(self, orderId):
1971 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1972 
    args = markOrderAsOutOfStock_args()
1973 
    args.orderId = orderId
1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
1978 
  def recv_markOrderAsOutOfStock(self, ):
1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
1985 
    result = markOrderAsOutOfStock_result()
1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
3431 rajveer 1988 
    if result.success is not None:
1208 chandransh 1989 
      return result.success
3431 rajveer 1990 
    if result.ex is not None:
1208 chandransh 1991 
      raise result.ex
1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1993 
 
3064 chandransh 1994 
  def verifyOrder(self, orderId):
759 chandransh 1995 
    """
3064 chandransh 1996 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1997 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1998 
    used for all other orders as well.
1999 
    Throws an exception if no such order exists.
3431 rajveer 2000 
 
759 chandransh 2001 
    Parameters:
3064 chandransh 2002 
     - orderId
759 chandransh 2003 
    """
3064 chandransh 2004 
    self.send_verifyOrder(orderId)
2005 
    return self.recv_verifyOrder()
759 chandransh 2006 
 
3064 chandransh 2007 
  def send_verifyOrder(self, orderId):
2008 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2009 
    args = verifyOrder_args()
2010 
    args.orderId = orderId
759 chandransh 2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
3064 chandransh 2015 
  def recv_verifyOrder(self, ):
759 chandransh 2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
3064 chandransh 2022 
    result = verifyOrder_result()
759 chandransh 2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
3431 rajveer 2025 
    if result.success is not None:
759 chandransh 2026 
      return result.success
3431 rajveer 2027 
    if result.ex is not None:
759 chandransh 2028 
      raise result.ex
3064 chandransh 2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2030 
 
3064 chandransh 2031 
  def acceptOrder(self, orderId):
1113 chandransh 2032 
    """
3064 chandransh 2033 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2034 
    given order is not a COD order, it also captures the payment if the same has
2035 
    not been captured.
2036 
    Throws an exception if no such order exists.
3431 rajveer 2037 
 
1113 chandransh 2038 
    Parameters:
3064 chandransh 2039 
     - orderId
1113 chandransh 2040 
    """
3064 chandransh 2041 
    self.send_acceptOrder(orderId)
2042 
    return self.recv_acceptOrder()
1113 chandransh 2043 
 
3064 chandransh 2044 
  def send_acceptOrder(self, orderId):
2045 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2046 
    args = acceptOrder_args()
2047 
    args.orderId = orderId
1113 chandransh 2048 
    args.write(self._oprot)
2049 
    self._oprot.writeMessageEnd()
2050 
    self._oprot.trans.flush()
2051 
 
3064 chandransh 2052 
  def recv_acceptOrder(self, ):
1113 chandransh 2053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2054 
    if mtype == TMessageType.EXCEPTION:
2055 
      x = TApplicationException()
2056 
      x.read(self._iprot)
2057 
      self._iprot.readMessageEnd()
2058 
      raise x
3064 chandransh 2059 
    result = acceptOrder_result()
1113 chandransh 2060 
    result.read(self._iprot)
2061 
    self._iprot.readMessageEnd()
3431 rajveer 2062 
    if result.success is not None:
1113 chandransh 2063 
      return result.success
3431 rajveer 2064 
    if result.ex is not None:
1113 chandransh 2065 
      raise result.ex
3064 chandransh 2066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2067 
 
4283 anupam.sin 2068 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2069 
    """
3064 chandransh 2070 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2071 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2072 
    the IMEI no. if a -1 is supplied.
2073 
    Also, it generates an invoice number for the order, marks the order as
2074 
    BILLED and sets the billing timestamp.
2075 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2076 
 
1135 chandransh 2077 
    Parameters:
3064 chandransh 2078 
     - orderId
2079 
     - invoice_number
4283 anupam.sin 2080 
     - imeiNumber
2081 
     - itemNumber
3064 chandransh 2082 
     - billed_by
4264 rajveer 2083 
     - jacketNumber
4283 anupam.sin 2084 
     - billingType
2085 
     - vendorId
1135 chandransh 2086 
    """
4283 anupam.sin 2087 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2088 
    return self.recv_addBillingDetails()
1135 chandransh 2089 
 
4283 anupam.sin 2090 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2091 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2092 
    args = addBillingDetails_args()
2093 
    args.orderId = orderId
2094 
    args.invoice_number = invoice_number
4283 anupam.sin 2095 
    args.imeiNumber = imeiNumber
2096 
    args.itemNumber = itemNumber
3064 chandransh 2097 
    args.billed_by = billed_by
4264 rajveer 2098 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2099 
    args.billingType = billingType
2100 
    args.vendorId = vendorId
1135 chandransh 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
3064 chandransh 2105 
  def recv_addBillingDetails(self, ):
1135 chandransh 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
3064 chandransh 2112 
    result = addBillingDetails_result()
1135 chandransh 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
3064 chandransh 2116 
      return result.success
3431 rajveer 2117 
    if result.ex is not None:
1135 chandransh 2118 
      raise result.ex
3064 chandransh 2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2120 
 
4579 rajveer 2121 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2122 
    """
2123 
    Add the invoice number to the order.
2124 
 
2125 
    Parameters:
2126 
     - orderId
2127 
     - invoiceNumber
2128 
    """
2129 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2130 
    self.recv_addInvoiceNumber()
2131 
 
2132 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2133 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2134 
    args = addInvoiceNumber_args()
2135 
    args.orderId = orderId
2136 
    args.invoiceNumber = invoiceNumber
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
2141 
  def recv_addInvoiceNumber(self, ):
2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
2148 
    result = addInvoiceNumber_result()
2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
2151 
    if result.ex is not None:
2152 
      raise result.ex
2153 
    return
2154 
 
3064 chandransh 2155 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2156 
    """
3064 chandransh 2157 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2158 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2159 
 
1408 ankur.sing 2160 
    Parameters:
3064 chandransh 2161 
     - warehouseId
1408 ankur.sing 2162 
     - providerId
3064 chandransh 2163 
     - cod
1408 ankur.sing 2164 
    """
3064 chandransh 2165 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2166 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2167 
 
3064 chandransh 2168 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2169 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2170 
    args = markOrdersAsManifested_args()
2171 
    args.warehouseId = warehouseId
1408 ankur.sing 2172 
    args.providerId = providerId
3064 chandransh 2173 
    args.cod = cod
1408 ankur.sing 2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
3064 chandransh 2178 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
3064 chandransh 2185 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
3431 rajveer 2188 
    if result.success is not None:
1408 ankur.sing 2189 
      return result.success
3431 rajveer 2190 
    if result.ex is not None:
3064 chandransh 2191 
      raise result.ex
2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2193 
 
4410 rajveer 2194 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2195 
    """
2196 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2197 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2198 
 
2199 
    Parameters:
2200 
     - warehouseId
2201 
     - providerId
2202 
     - cod
2203 
    """
2204 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2205 
    return self.recv_markOrdersAsShippedFromWarehouse()
2206 
 
2207 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2208 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2209 
    args = markOrdersAsShippedFromWarehouse_args()
2210 
    args.warehouseId = warehouseId
2211 
    args.providerId = providerId
2212 
    args.cod = cod
2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = markOrdersAsShippedFromWarehouse_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.success is not None:
2228 
      return result.success
2229 
    if result.ex is not None:
2230 
      raise result.ex
2231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2232 
 
3064 chandransh 2233 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2234 
    """
3064 chandransh 2235 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2236 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2237 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2238 
 
94 ashish 2239 
    Parameters:
3064 chandransh 2240 
     - providerId
2241 
     - pickupDetails
304 ashish 2242 
    """
3064 chandransh 2243 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2244 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2245 
 
3064 chandransh 2246 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2247 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2248 
    args = markOrdersAsPickedUp_args()
2249 
    args.providerId = providerId
2250 
    args.pickupDetails = pickupDetails
304 ashish 2251 
    args.write(self._oprot)
2252 
    self._oprot.writeMessageEnd()
2253 
    self._oprot.trans.flush()
2254 
 
3064 chandransh 2255 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2257 
    if mtype == TMessageType.EXCEPTION:
2258 
      x = TApplicationException()
2259 
      x.read(self._iprot)
2260 
      self._iprot.readMessageEnd()
2261 
      raise x
3064 chandransh 2262 
    result = markOrdersAsPickedUp_result()
304 ashish 2263 
    result.read(self._iprot)
2264 
    self._iprot.readMessageEnd()
3431 rajveer 2265 
    if result.success is not None:
304 ashish 2266 
      return result.success
3431 rajveer 2267 
    if result.ex is not None:
3064 chandransh 2268 
      raise result.ex
2269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2270 
 
3064 chandransh 2271 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2272 
    """
3064 chandransh 2273 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2274 
    the name of the receiver.
2275 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2276 
 
304 ashish 2277 
    Parameters:
3064 chandransh 2278 
     - providerId
2279 
     - deliveredOrders
304 ashish 2280 
    """
3064 chandransh 2281 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2282 
    self.recv_markOrdersAsDelivered()
304 ashish 2283 
 
3064 chandransh 2284 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2285 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2286 
    args = markOrdersAsDelivered_args()
2287 
    args.providerId = providerId
2288 
    args.deliveredOrders = deliveredOrders
304 ashish 2289 
    args.write(self._oprot)
2290 
    self._oprot.writeMessageEnd()
2291 
    self._oprot.trans.flush()
2292 
 
3064 chandransh 2293 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2295 
    if mtype == TMessageType.EXCEPTION:
2296 
      x = TApplicationException()
2297 
      x.read(self._iprot)
2298 
      self._iprot.readMessageEnd()
2299 
      raise x
3064 chandransh 2300 
    result = markOrdersAsDelivered_result()
304 ashish 2301 
    result.read(self._iprot)
2302 
    self._iprot.readMessageEnd()
3431 rajveer 2303 
    if result.ex is not None:
3064 chandransh 2304 
      raise result.ex
304 ashish 2305 
    return
2306 
 
3064 chandransh 2307 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2308 
    """
3064 chandransh 2309 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2310 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2311 
 
3064 chandransh 2312 
    Parameters:
2313 
     - providerId
2314 
     - returnedOrders
1596 ankur.sing 2315 
    """
3064 chandransh 2316 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2317 
    self.recv_markOrdersAsFailed()
304 ashish 2318 
 
3064 chandransh 2319 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2320 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2321 
    args = markOrdersAsFailed_args()
2322 
    args.providerId = providerId
2323 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2324 
    args.write(self._oprot)
2325 
    self._oprot.writeMessageEnd()
2326 
    self._oprot.trans.flush()
2327 
 
3064 chandransh 2328 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2330 
    if mtype == TMessageType.EXCEPTION:
2331 
      x = TApplicationException()
2332 
      x.read(self._iprot)
2333 
      self._iprot.readMessageEnd()
2334 
      raise x
3064 chandransh 2335 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2336 
    result.read(self._iprot)
2337 
    self._iprot.readMessageEnd()
3431 rajveer 2338 
    if result.ex is not None:
3064 chandransh 2339 
      raise result.ex
2340 
    return
1596 ankur.sing 2341 
 
3064 chandransh 2342 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2343 
    """
3064 chandransh 2344 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2345 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2346 
 
3064 chandransh 2347 
    Parameters:
2348 
     - providerId
2349 
     - undeliveredOrders
1627 ankur.sing 2350 
    """
3064 chandransh 2351 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2352 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2353 
 
3064 chandransh 2354 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2355 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2356 
    args = updateNonDeliveryReason_args()
2357 
    args.providerId = providerId
2358 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2359 
    args.write(self._oprot)
2360 
    self._oprot.writeMessageEnd()
2361 
    self._oprot.trans.flush()
2362 
 
3064 chandransh 2363 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2365 
    if mtype == TMessageType.EXCEPTION:
2366 
      x = TApplicationException()
2367 
      x.read(self._iprot)
2368 
      self._iprot.readMessageEnd()
2369 
      raise x
3064 chandransh 2370 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2371 
    result.read(self._iprot)
2372 
    self._iprot.readMessageEnd()
4581 phani.kuma 2373 
    if result.success is not None:
2374 
      return result.success
3431 rajveer 2375 
    if result.ex is not None:
3064 chandransh 2376 
      raise result.ex
4581 phani.kuma 2377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2378 
 
3064 chandransh 2379 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2380 
    """
3064 chandransh 2381 
    Returns the list of orders whose delivery time has passed but have not been
2382 
    delivered yet for the given provider and warehouse. To get a complete list of
2383 
    undelivered orders, pass them as -1.
2384 
    Returns an empty list if no such orders exist.
3431 rajveer 2385 
 
1886 ankur.sing 2386 
    Parameters:
3064 chandransh 2387 
     - providerId
2388 
     - warehouseId
1886 ankur.sing 2389 
    """
3064 chandransh 2390 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2391 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2392 
 
3064 chandransh 2393 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2394 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2395 
    args = getUndeliveredOrders_args()
2396 
    args.providerId = providerId
2397 
    args.warehouseId = warehouseId
1886 ankur.sing 2398 
    args.write(self._oprot)
2399 
    self._oprot.writeMessageEnd()
2400 
    self._oprot.trans.flush()
2401 
 
3064 chandransh 2402 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2404 
    if mtype == TMessageType.EXCEPTION:
2405 
      x = TApplicationException()
2406 
      x.read(self._iprot)
2407 
      self._iprot.readMessageEnd()
2408 
      raise x
3064 chandransh 2409 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2410 
    result.read(self._iprot)
2411 
    self._iprot.readMessageEnd()
3431 rajveer 2412 
    if result.success is not None:
1886 ankur.sing 2413 
      return result.success
3064 chandransh 2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2415 
 
2536 chandransh 2416 
  def toggleDOAFlag(self, orderId):
2417 
    """
2418 
    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.
2419 
    Returns the final flag status.
2420 
    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 2421 
 
2536 chandransh 2422 
    Parameters:
2423 
     - orderId
2424 
    """
2425 
    self.send_toggleDOAFlag(orderId)
2426 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2427 
 
2536 chandransh 2428 
  def send_toggleDOAFlag(self, orderId):
2429 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2430 
    args = toggleDOAFlag_args()
2431 
    args.orderId = orderId
2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
2436 
  def recv_toggleDOAFlag(self, ):
2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
2443 
    result = toggleDOAFlag_result()
2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
3431 rajveer 2446 
    if result.success is not None:
2536 chandransh 2447 
      return result.success
3431 rajveer 2448 
    if result.ex is not None:
2536 chandransh 2449 
      raise result.ex
2450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2451 
 
4454 rajveer 2452 
  def markOrderDoaRequestReceived(self, orderId):
2453 
    """
2454 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2455 
 
2456 
    Parameters:
2457 
     - orderId
2458 
    """
2459 
    self.send_markOrderDoaRequestReceived(orderId)
2460 
    return self.recv_markOrderDoaRequestReceived()
2461 
 
2462 
  def send_markOrderDoaRequestReceived(self, orderId):
2463 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2464 
    args = markOrderDoaRequestReceived_args()
2465 
    args.orderId = orderId
2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
2470 
  def recv_markOrderDoaRequestReceived(self, ):
2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
2477 
    result = markOrderDoaRequestReceived_result()
2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
2480 
    if result.success is not None:
2481 
      return result.success
2482 
    if result.ex is not None:
2483 
      raise result.ex
2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2485 
 
2486 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2487 
    """
2488 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2489 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2490 
 
2491 
    Parameters:
2492 
     - orderId
2493 
     - isAuthorized
2494 
    """
2495 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2496 
    return self.recv_markOrderDoaRequestAuthorized()
2497 
 
2498 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2499 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2500 
    args = markOrderDoaRequestAuthorized_args()
2501 
    args.orderId = orderId
2502 
    args.isAuthorized = isAuthorized
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_markOrderDoaRequestAuthorized(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = markOrderDoaRequestAuthorized_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.success is not None:
2518 
      return result.success
2519 
    if result.ex is not None:
2520 
      raise result.ex
2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2522 
 
4488 rajveer 2523 
  def markOrderReturnRequestReceived(self, orderId):
2524 
    """
2525 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2526 
 
2527 
    Parameters:
2528 
     - orderId
2529 
    """
2530 
    self.send_markOrderReturnRequestReceived(orderId)
2531 
    return self.recv_markOrderReturnRequestReceived()
2532 
 
2533 
  def send_markOrderReturnRequestReceived(self, orderId):
2534 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2535 
    args = markOrderReturnRequestReceived_args()
2536 
    args.orderId = orderId
2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_markOrderReturnRequestReceived(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = markOrderReturnRequestReceived_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
2551 
    if result.success is not None:
2552 
      return result.success
2553 
    if result.ex is not None:
2554 
      raise result.ex
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2556 
 
2557 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2558 
    """
2559 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2560 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2561 
 
2562 
    Parameters:
2563 
     - orderId
2564 
     - isAuthorized
2565 
    """
2566 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2567 
    return self.recv_markOrderReturnRequestAuthorized()
2568 
 
2569 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2570 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2571 
    args = markOrderReturnRequestAuthorized_args()
2572 
    args.orderId = orderId
2573 
    args.isAuthorized = isAuthorized
2574 
    args.write(self._oprot)
2575 
    self._oprot.writeMessageEnd()
2576 
    self._oprot.trans.flush()
2577 
 
2578 
  def recv_markOrderReturnRequestAuthorized(self, ):
2579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2580 
    if mtype == TMessageType.EXCEPTION:
2581 
      x = TApplicationException()
2582 
      x.read(self._iprot)
2583 
      self._iprot.readMessageEnd()
2584 
      raise x
2585 
    result = markOrderReturnRequestAuthorized_result()
2586 
    result.read(self._iprot)
2587 
    self._iprot.readMessageEnd()
2588 
    if result.success is not None:
2589 
      return result.success
2590 
    if result.ex is not None:
2591 
      raise result.ex
2592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2593 
 
4579 rajveer 2594 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2595 
    """
2596 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2597 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2598 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2599 
    For any other status, it returns false.
2600 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2601 
 
2536 chandransh 2602 
    Parameters:
2603 
     - orderId
4579 rajveer 2604 
     - providerId
2536 chandransh 2605 
    """
4579 rajveer 2606 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2607 
    return self.recv_requestPickupNumber()
2608 
 
4579 rajveer 2609 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2610 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2611 
    args = requestPickupNumber_args()
2612 
    args.orderId = orderId
4579 rajveer 2613 
    args.providerId = providerId
2536 chandransh 2614 
    args.write(self._oprot)
2615 
    self._oprot.writeMessageEnd()
2616 
    self._oprot.trans.flush()
2617 
 
2618 
  def recv_requestPickupNumber(self, ):
2619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2620 
    if mtype == TMessageType.EXCEPTION:
2621 
      x = TApplicationException()
2622 
      x.read(self._iprot)
2623 
      self._iprot.readMessageEnd()
2624 
      raise x
2625 
    result = requestPickupNumber_result()
2626 
    result.read(self._iprot)
2627 
    self._iprot.readMessageEnd()
3431 rajveer 2628 
    if result.success is not None:
2536 chandransh 2629 
      return result.success
3431 rajveer 2630 
    if result.ex is not None:
2536 chandransh 2631 
      raise result.ex
2632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2633 
 
2634 
  def authorizePickup(self, orderId, pickupNumber):
2635 
    """
4452 rajveer 2636 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2637 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2638 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2639 
    	3. Returns true
2591 chandransh 2640 
    If the order is in any other status, it returns false.
2536 chandransh 2641 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2642 
 
2536 chandransh 2643 
    Parameters:
2644 
     - orderId
2645 
     - pickupNumber
2646 
    """
2647 
    self.send_authorizePickup(orderId, pickupNumber)
2648 
    return self.recv_authorizePickup()
2649 
 
2650 
  def send_authorizePickup(self, orderId, pickupNumber):
2651 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2652 
    args = authorizePickup_args()
2653 
    args.orderId = orderId
2654 
    args.pickupNumber = pickupNumber
2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
2659 
  def recv_authorizePickup(self, ):
2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
2666 
    result = authorizePickup_result()
2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
3431 rajveer 2669 
    if result.success is not None:
2536 chandransh 2670 
      return result.success
3431 rajveer 2671 
    if result.ex is not None:
2536 chandransh 2672 
      raise result.ex
2673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2674 
 
2764 chandransh 2675 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2676 
    """
2677 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2678 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2679 
 
2764 chandransh 2680 
    Parameters:
2681 
     - providerId
2682 
     - pickupDetails
2683 
    """
2684 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2685 
    return self.recv_markDoasAsPickedUp()
2686 
 
2687 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2688 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2689 
    args = markDoasAsPickedUp_args()
2690 
    args.providerId = providerId
2691 
    args.pickupDetails = pickupDetails
2692 
    args.write(self._oprot)
2693 
    self._oprot.writeMessageEnd()
2694 
    self._oprot.trans.flush()
2695 
 
2696 
  def recv_markDoasAsPickedUp(self, ):
2697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2698 
    if mtype == TMessageType.EXCEPTION:
2699 
      x = TApplicationException()
2700 
      x.read(self._iprot)
2701 
      self._iprot.readMessageEnd()
2702 
      raise x
2703 
    result = markDoasAsPickedUp_result()
2704 
    result.read(self._iprot)
2705 
    self._iprot.readMessageEnd()
3431 rajveer 2706 
    if result.success is not None:
2764 chandransh 2707 
      return result.success
2708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2709 
 
4479 rajveer 2710 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2711 
    """
4452 rajveer 2712 
    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 2713 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2714 
    If the order is in any other state, it returns false.
2715 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2716 
 
2591 chandransh 2717 
    Parameters:
2718 
     - orderId
4479 rajveer 2719 
     - receiveCondition
2591 chandransh 2720 
    """
4479 rajveer 2721 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2722 
    return self.recv_receiveReturn()
2536 chandransh 2723 
 
4479 rajveer 2724 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2725 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2726 
    args = receiveReturn_args()
2591 chandransh 2727 
    args.orderId = orderId
4479 rajveer 2728 
    args.receiveCondition = receiveCondition
2591 chandransh 2729 
    args.write(self._oprot)
2730 
    self._oprot.writeMessageEnd()
2731 
    self._oprot.trans.flush()
2732 
 
2616 chandransh 2733 
  def recv_receiveReturn(self, ):
2591 chandransh 2734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2735 
    if mtype == TMessageType.EXCEPTION:
2736 
      x = TApplicationException()
2737 
      x.read(self._iprot)
2738 
      self._iprot.readMessageEnd()
2739 
      raise x
2616 chandransh 2740 
    result = receiveReturn_result()
2591 chandransh 2741 
    result.read(self._iprot)
2742 
    self._iprot.readMessageEnd()
3431 rajveer 2743 
    if result.success is not None:
2591 chandransh 2744 
      return result.success
3431 rajveer 2745 
    if result.ex is not None:
2591 chandransh 2746 
      raise result.ex
2616 chandransh 2747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2748 
 
2749 
  def validateDoa(self, orderId, isValid):
2750 
    """
4452 rajveer 2751 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2752 
    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 2753 
    If the order is in any other state, it returns false.
2754 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2755 
 
2591 chandransh 2756 
    Parameters:
2757 
     - orderId
2758 
     - isValid
2759 
    """
2760 
    self.send_validateDoa(orderId, isValid)
2761 
    return self.recv_validateDoa()
2762 
 
2763 
  def send_validateDoa(self, orderId, isValid):
2764 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2765 
    args = validateDoa_args()
2766 
    args.orderId = orderId
2767 
    args.isValid = isValid
2768 
    args.write(self._oprot)
2769 
    self._oprot.writeMessageEnd()
2770 
    self._oprot.trans.flush()
2771 
 
2772 
  def recv_validateDoa(self, ):
2773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2774 
    if mtype == TMessageType.EXCEPTION:
2775 
      x = TApplicationException()
2776 
      x.read(self._iprot)
2777 
      self._iprot.readMessageEnd()
2778 
      raise x
2779 
    result = validateDoa_result()
2780 
    result.read(self._iprot)
2781 
    self._iprot.readMessageEnd()
3431 rajveer 2782 
    if result.success is not None:
2591 chandransh 2783 
      return result.success
3431 rajveer 2784 
    if result.ex is not None:
2591 chandransh 2785 
      raise result.ex
2786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2787 
 
4495 rajveer 2788 
  def validateReturnProduct(self, orderId, isUsable):
2789 
    """
2790 
    Parameters:
2791 
     - orderId
2792 
     - isUsable
2793 
    """
2794 
    self.send_validateReturnProduct(orderId, isUsable)
2795 
    return self.recv_validateReturnProduct()
2796 
 
2797 
  def send_validateReturnProduct(self, orderId, isUsable):
2798 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2799 
    args = validateReturnProduct_args()
2800 
    args.orderId = orderId
2801 
    args.isUsable = isUsable
2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2806 
  def recv_validateReturnProduct(self, ):
2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2813 
    result = validateReturnProduct_result()
2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
2816 
    if result.success is not None:
2817 
      return result.success
2818 
    if result.ex is not None:
2819 
      raise result.ex
2820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2821 
 
2616 chandransh 2822 
  def reshipOrder(self, orderId):
2823 
    """
4484 rajveer 2824 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2825 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2826 
    	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 2827 
 
2828 
    If the order is in DOA_CERT_VALID state, it does the following:
2829 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2830 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2831 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2832 
 
2616 chandransh 2833 
    Returns the id of the newly created order.
3431 rajveer 2834 
 
2616 chandransh 2835 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2836 
 
2616 chandransh 2837 
    Parameters:
2838 
     - orderId
2839 
    """
2840 
    self.send_reshipOrder(orderId)
2841 
    return self.recv_reshipOrder()
2591 chandransh 2842 
 
2616 chandransh 2843 
  def send_reshipOrder(self, orderId):
2844 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2845 
    args = reshipOrder_args()
2846 
    args.orderId = orderId
2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
2851 
  def recv_reshipOrder(self, ):
2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
2858 
    result = reshipOrder_result()
2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
3431 rajveer 2861 
    if result.success is not None:
2616 chandransh 2862 
      return result.success
3431 rajveer 2863 
    if result.ex is not None:
2616 chandransh 2864 
      raise result.ex
2865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2866 
 
3226 chandransh 2867 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2868 
    """
4484 rajveer 2869 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2870 
    	1. Creates a refund request for batch processing.
2871 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2872 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2873 
 
2616 chandransh 2874 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2875 
    	1. Creates a refund request for batch processing.
3226 chandransh 2876 
    	2. Cancels the reservation of the item in the warehouse.
2877 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2878 
 
3226 chandransh 2879 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2880 
    	1. Cancels the reservation of the item in the warehouse.
2881 
    	2. Marks the current order as CANCELED.
2882 
 
2883 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2884 
 
2616 chandransh 2885 
    Returns True if it is successful, False otherwise.
3431 rajveer 2886 
 
2616 chandransh 2887 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2888 
 
2616 chandransh 2889 
    Parameters:
2890 
     - orderId
3226 chandransh 2891 
     - refundedBy
2892 
     - reason
2616 chandransh 2893 
    """
3226 chandransh 2894 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2895 
    return self.recv_refundOrder()
2896 
 
3226 chandransh 2897 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2898 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2899 
    args = refundOrder_args()
2900 
    args.orderId = orderId
3226 chandransh 2901 
    args.refundedBy = refundedBy
2902 
    args.reason = reason
2616 chandransh 2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
2907 
  def recv_refundOrder(self, ):
2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
2914 
    result = refundOrder_result()
2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
3431 rajveer 2917 
    if result.success is not None:
2616 chandransh 2918 
      return result.success
3431 rajveer 2919 
    if result.ex is not None:
2616 chandransh 2920 
      raise result.ex
2921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2922 
 
2690 chandransh 2923 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2924 
    """
2925 
    Get all return orders created between the from and to dates for the given warehouse.
2926 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2927 
 
2690 chandransh 2928 
    Parameters:
2929 
     - warehouseId
2930 
     - fromDate
2931 
     - toDate
2932 
    """
2933 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2934 
    return self.recv_getReturnOrders()
2616 chandransh 2935 
 
2690 chandransh 2936 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2937 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2938 
    args = getReturnOrders_args()
2939 
    args.warehouseId = warehouseId
2940 
    args.fromDate = fromDate
2941 
    args.toDate = toDate
2942 
    args.write(self._oprot)
2943 
    self._oprot.writeMessageEnd()
2944 
    self._oprot.trans.flush()
2945 
 
2946 
  def recv_getReturnOrders(self, ):
2947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2948 
    if mtype == TMessageType.EXCEPTION:
2949 
      x = TApplicationException()
2950 
      x.read(self._iprot)
2951 
      self._iprot.readMessageEnd()
2952 
      raise x
2953 
    result = getReturnOrders_result()
2954 
    result.read(self._iprot)
2955 
    self._iprot.readMessageEnd()
3431 rajveer 2956 
    if result.success is not None:
2690 chandransh 2957 
      return result.success
2958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2959 
 
2700 chandransh 2960 
  def getReturnOrder(self, id):
2961 
    """
2962 
    Returns the ReturnOrder corresponding to the given id.
2963 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2964 
 
2700 chandransh 2965 
    Parameters:
2966 
     - id
2967 
    """
2968 
    self.send_getReturnOrder(id)
2969 
    return self.recv_getReturnOrder()
2970 
 
2971 
  def send_getReturnOrder(self, id):
2972 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2973 
    args = getReturnOrder_args()
2974 
    args.id = id
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_getReturnOrder(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = getReturnOrder_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
3431 rajveer 2989 
    if result.success is not None:
2700 chandransh 2990 
      return result.success
3431 rajveer 2991 
    if result.ex is not None:
2700 chandransh 2992 
      raise result.ex
2993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2994 
 
2690 chandransh 2995 
  def processReturn(self, returnOrderId):
2996 
    """
2997 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2998 
 
2690 chandransh 2999 
    Parameters:
3000 
     - returnOrderId
3001 
    """
3002 
    self.send_processReturn(returnOrderId)
3003 
    self.recv_processReturn()
3004 
 
3005 
  def send_processReturn(self, returnOrderId):
3006 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3007 
    args = processReturn_args()
3008 
    args.returnOrderId = returnOrderId
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_processReturn(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = processReturn_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3431 rajveer 3023 
    if result.ex is not None:
2690 chandransh 3024 
      raise result.ex
3025 
    return
3026 
 
2819 chandransh 3027 
  def createPurchaseOrder(self, warehouseId):
3028 
    """
4586 mandeep.dh 3029 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3030 
    Returns the list of PO no. of the newly created purchase order.
3031 
    Returns null if no new purchase order had to be created.
3431 rajveer 3032 
 
2819 chandransh 3033 
    Parameters:
3034 
     - warehouseId
3035 
    """
3036 
    self.send_createPurchaseOrder(warehouseId)
3037 
    return self.recv_createPurchaseOrder()
2690 chandransh 3038 
 
2819 chandransh 3039 
  def send_createPurchaseOrder(self, warehouseId):
3040 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3041 
    args = createPurchaseOrder_args()
3042 
    args.warehouseId = warehouseId
3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
3047 
  def recv_createPurchaseOrder(self, ):
3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
3054 
    result = createPurchaseOrder_result()
3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3431 rajveer 3057 
    if result.success is not None:
2819 chandransh 3058 
      return result.success
3431 rajveer 3059 
    if result.ex is not None:
2819 chandransh 3060 
      raise result.ex
3061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3062 
 
3451 chandransh 3063 
  def updateWeight(self, orderId, weight):
3064 
    """
3065 
    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 3066 
 
3451 chandransh 3067 
    Parameters:
3068 
     - orderId
3069 
     - weight
3070 
    """
3071 
    self.send_updateWeight(orderId, weight)
3072 
    return self.recv_updateWeight()
3073 
 
3074 
  def send_updateWeight(self, orderId, weight):
3075 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3076 
    args = updateWeight_args()
3077 
    args.orderId = orderId
3078 
    args.weight = weight
3079 
    args.write(self._oprot)
3080 
    self._oprot.writeMessageEnd()
3081 
    self._oprot.trans.flush()
3082 
 
3083 
  def recv_updateWeight(self, ):
3084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3085 
    if mtype == TMessageType.EXCEPTION:
3086 
      x = TApplicationException()
3087 
      x.read(self._iprot)
3088 
      self._iprot.readMessageEnd()
3089 
      raise x
3090 
    result = updateWeight_result()
3091 
    result.read(self._iprot)
3092 
    self._iprot.readMessageEnd()
3093 
    if result.success is not None:
3094 
      return result.success
3095 
    if result.ex is not None:
3096 
      raise result.ex
3097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3098 
 
3469 chandransh 3099 
  def changeItem(self, orderId, itemId):
3100 
    """
3101 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3102 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3103 
 
3469 chandransh 3104 
    Parameters:
3105 
     - orderId
3106 
     - itemId
3107 
    """
3108 
    self.send_changeItem(orderId, itemId)
3109 
    return self.recv_changeItem()
3110 
 
3111 
  def send_changeItem(self, orderId, itemId):
3112 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3113 
    args = changeItem_args()
3114 
    args.orderId = orderId
3115 
    args.itemId = itemId
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_changeItem(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = changeItem_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3130 
    if result.success is not None:
3131 
      return result.success
3132 
    if result.ex is not None:
3133 
      raise result.ex
3134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3135 
 
3136 
  def shiftToWarehouse(self, orderId, warehouseId):
3137 
    """
3138 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3139 
 
3140 
    Parameters:
3141 
     - orderId
3142 
     - warehouseId
3143 
    """
3144 
    self.send_shiftToWarehouse(orderId, warehouseId)
3145 
    return self.recv_shiftToWarehouse()
3146 
 
3147 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3148 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3149 
    args = shiftToWarehouse_args()
3150 
    args.orderId = orderId
3151 
    args.warehouseId = warehouseId
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
3156 
  def recv_shiftToWarehouse(self, ):
3157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3158 
    if mtype == TMessageType.EXCEPTION:
3159 
      x = TApplicationException()
3160 
      x.read(self._iprot)
3161 
      self._iprot.readMessageEnd()
3162 
      raise x
3163 
    result = shiftToWarehouse_result()
3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.success is not None:
3167 
      return result.success
3168 
    if result.ex is not None:
3169 
      raise result.ex
3170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3171 
 
3986 chandransh 3172 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3173 
    """
3174 
    Adds the given delay reason to the given order.
3986 chandransh 3175 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3176 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3177 
 
3553 chandransh 3178 
    Parameters:
3179 
     - orderId
3180 
     - delayReason
3986 chandransh 3181 
     - furtherDelay
3553 chandransh 3182 
    """
3986 chandransh 3183 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3184 
    return self.recv_addDelayReason()
3185 
 
3986 chandransh 3186 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3187 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3188 
    args = addDelayReason_args()
3189 
    args.orderId = orderId
3190 
    args.delayReason = delayReason
3986 chandransh 3191 
    args.furtherDelay = furtherDelay
3553 chandransh 3192 
    args.write(self._oprot)
3193 
    self._oprot.writeMessageEnd()
3194 
    self._oprot.trans.flush()
3195 
 
3196 
  def recv_addDelayReason(self, ):
3197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3198 
    if mtype == TMessageType.EXCEPTION:
3199 
      x = TApplicationException()
3200 
      x.read(self._iprot)
3201 
      self._iprot.readMessageEnd()
3202 
      raise x
3203 
    result = addDelayReason_result()
3204 
    result.read(self._iprot)
3205 
    self._iprot.readMessageEnd()
3206 
    if result.success is not None:
3207 
      return result.success
3208 
    if result.ex is not None:
3209 
      raise result.ex
3210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3211 
 
3956 chandransh 3212 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3213 
    """
3214 
    Marks the COD orders with given AWB nos. as having been processed.
3215 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3216 
 
3956 chandransh 3217 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3218 
    1. There is no order corresponding to an AWB number.
3219 
    2. The captured amount for a payment exceeds the total payment.
3220 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3221 
 
3222 
    Parameters:
3223 
     - collectedAmountMap
3224 
     - xferBy
3225 
     - xferTxnId
3226 
     - xferDate
3227 
    """
3228 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3229 
    return self.recv_reconcileCodCollection()
3230 
 
3231 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3232 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3233 
    args = reconcileCodCollection_args()
3234 
    args.collectedAmountMap = collectedAmountMap
3235 
    args.xferBy = xferBy
3236 
    args.xferTxnId = xferTxnId
3237 
    args.xferDate = xferDate
3238 
    args.write(self._oprot)
3239 
    self._oprot.writeMessageEnd()
3240 
    self._oprot.trans.flush()
3241 
 
3242 
  def recv_reconcileCodCollection(self, ):
3243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3244 
    if mtype == TMessageType.EXCEPTION:
3245 
      x = TApplicationException()
3246 
      x.read(self._iprot)
3247 
      self._iprot.readMessageEnd()
3248 
      raise x
3249 
    result = reconcileCodCollection_result()
3250 
    result.read(self._iprot)
3251 
    self._iprot.readMessageEnd()
3252 
    if result.success is not None:
3253 
      return result.success
3254 
    if result.ex is not None:
3255 
      raise result.ex
3256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3257 
 
4008 mandeep.dh 3258 
  def getTransactionsRequiringExtraProcessing(self, category):
3259 
    """
4065 mandeep.dh 3260 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3261 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3262 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3263 
 
4008 mandeep.dh 3264 
    Parameters:
3265 
     - category
3266 
    """
3267 
    self.send_getTransactionsRequiringExtraProcessing(category)
3268 
    return self.recv_getTransactionsRequiringExtraProcessing()
3269 
 
3270 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3271 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3272 
    args = getTransactionsRequiringExtraProcessing_args()
3273 
    args.category = category
3274 
    args.write(self._oprot)
3275 
    self._oprot.writeMessageEnd()
3276 
    self._oprot.trans.flush()
3277 
 
3278 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3280 
    if mtype == TMessageType.EXCEPTION:
3281 
      x = TApplicationException()
3282 
      x.read(self._iprot)
3283 
      self._iprot.readMessageEnd()
3284 
      raise x
3285 
    result = getTransactionsRequiringExtraProcessing_result()
3286 
    result.read(self._iprot)
3287 
    self._iprot.readMessageEnd()
3288 
    if result.success is not None:
3289 
      return result.success
3290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3291 
 
3292 
  def markTransactionAsProcessed(self, transactionId, category):
3293 
    """
3294 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3295 
    It essentially deletes the transaction id record for a particular
3296 
    processing type category (if present) from DB.
3297 
    This is currently used by CRM application.
4008 mandeep.dh 3298 
 
3299 
    Parameters:
3300 
     - transactionId
3301 
     - category
3302 
    """
3303 
    self.send_markTransactionAsProcessed(transactionId, category)
3304 
    self.recv_markTransactionAsProcessed()
3305 
 
3306 
  def send_markTransactionAsProcessed(self, transactionId, category):
3307 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3308 
    args = markTransactionAsProcessed_args()
3309 
    args.transactionId = transactionId
3310 
    args.category = category
3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3315 
  def recv_markTransactionAsProcessed(self, ):
3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3322 
    result = markTransactionAsProcessed_result()
3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3325 
    return
3326 
 
4018 chandransh 3327 
  def getItemWiseRiskyOrdersCount(self, ):
3328 
    """
3329 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3330 
    is defined as one whose shipping date is about to expire.
3331 
    """
3332 
    self.send_getItemWiseRiskyOrdersCount()
3333 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3334 
 
4018 chandransh 3335 
  def send_getItemWiseRiskyOrdersCount(self, ):
3336 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3337 
    args = getItemWiseRiskyOrdersCount_args()
3338 
    args.write(self._oprot)
3339 
    self._oprot.writeMessageEnd()
3340 
    self._oprot.trans.flush()
3341 
 
3342 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3344 
    if mtype == TMessageType.EXCEPTION:
3345 
      x = TApplicationException()
3346 
      x.read(self._iprot)
3347 
      self._iprot.readMessageEnd()
3348 
      raise x
3349 
    result = getItemWiseRiskyOrdersCount_result()
3350 
    result.read(self._iprot)
3351 
    self._iprot.readMessageEnd()
3352 
    if result.success is not None:
3353 
      return result.success
3354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3355 
 
4295 varun.gupt 3356 
  def getOrdersForItemIds(self, itemIds):
3357 
    """
3358 
    Returns a list of all orders which have items with given id
3359 
 
3360 
    Parameters:
3361 
     - itemIds
3362 
    """
3363 
    self.send_getOrdersForItemIds(itemIds)
3364 
    return self.recv_getOrdersForItemIds()
3365 
 
3366 
  def send_getOrdersForItemIds(self, itemIds):
3367 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3368 
    args = getOrdersForItemIds_args()
3369 
    args.itemIds = itemIds
3370 
    args.write(self._oprot)
3371 
    self._oprot.writeMessageEnd()
3372 
    self._oprot.trans.flush()
3373 
 
3374 
  def recv_getOrdersForItemIds(self, ):
3375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3376 
    if mtype == TMessageType.EXCEPTION:
3377 
      x = TApplicationException()
3378 
      x.read(self._iprot)
3379 
      self._iprot.readMessageEnd()
3380 
      raise x
3381 
    result = getOrdersForItemIds_result()
3382 
    result.read(self._iprot)
3383 
    self._iprot.readMessageEnd()
3384 
    if result.success is not None:
3385 
      return result.success
3386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3387 
 
4247 rajveer 3388 
  def markOrderCancellationRequestReceived(self, orderId):
3389 
    """
3390 
    Mark order as cancellation request received. If customer sends request of cancellation of
3391 
    a particular order, this method will be called. It will just change status of the order
3392 
    depending on its current status. It also records the previous status, so that we can move
3393 
    back to that status if cancellation request is denied.
4018 chandransh 3394 
 
4247 rajveer 3395 
    Parameters:
3396 
     - orderId
3397 
    """
3398 
    self.send_markOrderCancellationRequestReceived(orderId)
3399 
    self.recv_markOrderCancellationRequestReceived()
3400 
 
3401 
  def send_markOrderCancellationRequestReceived(self, orderId):
3402 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3403 
    args = markOrderCancellationRequestReceived_args()
3404 
    args.orderId = orderId
3405 
    args.write(self._oprot)
3406 
    self._oprot.writeMessageEnd()
3407 
    self._oprot.trans.flush()
3408 
 
3409 
  def recv_markOrderCancellationRequestReceived(self, ):
3410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3411 
    if mtype == TMessageType.EXCEPTION:
3412 
      x = TApplicationException()
3413 
      x.read(self._iprot)
3414 
      self._iprot.readMessageEnd()
3415 
      raise x
3416 
    result = markOrderCancellationRequestReceived_result()
3417 
    result.read(self._iprot)
3418 
    self._iprot.readMessageEnd()
3419 
    if result.ex is not None:
3420 
      raise result.ex
3421 
    return
3422 
 
3423 
  def markOrderCancellationRequestConfirmed(self, orderId):
3424 
    """
3425 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3426 
    cancellation request confirmed. After this OM will be able to cancel the order.
3427 
 
3428 
    Parameters:
3429 
     - orderId
3430 
    """
3431 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3432 
    self.recv_markOrderCancellationRequestConfirmed()
3433 
 
3434 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3435 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3436 
    args = markOrderCancellationRequestConfirmed_args()
3437 
    args.orderId = orderId
3438 
    args.write(self._oprot)
3439 
    self._oprot.writeMessageEnd()
3440 
    self._oprot.trans.flush()
3441 
 
3442 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3444 
    if mtype == TMessageType.EXCEPTION:
3445 
      x = TApplicationException()
3446 
      x.read(self._iprot)
3447 
      self._iprot.readMessageEnd()
3448 
      raise x
3449 
    result = markOrderCancellationRequestConfirmed_result()
3450 
    result.read(self._iprot)
3451 
    self._iprot.readMessageEnd()
3452 
    if result.ex is not None:
3453 
      raise result.ex
3454 
    return
3455 
 
3456 
  def markOrderCancellationRequestDenied(self, orderId):
3457 
    """
3458 
    If we decide to not to cancel order, we will move the order ro previous status.
3459 
 
3460 
    Parameters:
3461 
     - orderId
3462 
    """
3463 
    self.send_markOrderCancellationRequestDenied(orderId)
3464 
    self.recv_markOrderCancellationRequestDenied()
3465 
 
3466 
  def send_markOrderCancellationRequestDenied(self, orderId):
3467 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3468 
    args = markOrderCancellationRequestDenied_args()
3469 
    args.orderId = orderId
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_markOrderCancellationRequestDenied(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = markOrderCancellationRequestDenied_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3484 
    if result.ex is not None:
3485 
      raise result.ex
3486 
    return
3487 
 
4258 rajveer 3488 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3489 
    """
4258 rajveer 3490 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3491 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3492 
 
3493 
    Parameters:
4258 rajveer 3494 
     - transactionId
4247 rajveer 3495 
    """
4258 rajveer 3496 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3497 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3498 
 
4258 rajveer 3499 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3500 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3501 
    args = markTransactionAsPaymentFlagRemoved_args()
3502 
    args.transactionId = transactionId
4247 rajveer 3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
4258 rajveer 3507 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
4258 rajveer 3514 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3517 
    if result.ex is not None:
3518 
      raise result.ex
3519 
    return
3520 
 
4259 anupam.sin 3521 
  def refundTransaction(self, transactionId, refundedBy, reason):
3522 
    """
3523 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3524 
    need to be cancelled
4247 rajveer 3525 
 
4259 anupam.sin 3526 
    Parameters:
3527 
     - transactionId
3528 
     - refundedBy
3529 
     - reason
3530 
    """
3531 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3532 
    self.recv_refundTransaction()
3533 
 
3534 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3535 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3536 
    args = refundTransaction_args()
3537 
    args.transactionId = transactionId
3538 
    args.refundedBy = refundedBy
3539 
    args.reason = reason
3540 
    args.write(self._oprot)
3541 
    self._oprot.writeMessageEnd()
3542 
    self._oprot.trans.flush()
3543 
 
3544 
  def recv_refundTransaction(self, ):
3545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3546 
    if mtype == TMessageType.EXCEPTION:
3547 
      x = TApplicationException()
3548 
      x.read(self._iprot)
3549 
      self._iprot.readMessageEnd()
3550 
      raise x
3551 
    result = refundTransaction_result()
3552 
    result.read(self._iprot)
3553 
    self._iprot.readMessageEnd()
3554 
    if result.ex is not None:
3555 
      raise result.ex
3556 
    return
3557 
 
4324 mandeep.dh 3558 
  def updateShipmentAddress(self, orderId, addressId):
3559 
    """
3560 
    Updates shipment address of an order. Delivery and shipping date estimates
3561 
    etc. are also updated here.
3562 
 
3563 
    Throws TransactionServiceException in case address change is not
3564 
    possible due to certain reasons such as new pincode in address is
3565 
    not serviceable etc.
3566 
 
3567 
    Parameters:
3568 
     - orderId
3569 
     - addressId
3570 
    """
3571 
    self.send_updateShipmentAddress(orderId, addressId)
3572 
    self.recv_updateShipmentAddress()
3573 
 
3574 
  def send_updateShipmentAddress(self, orderId, addressId):
3575 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3576 
    args = updateShipmentAddress_args()
3577 
    args.orderId = orderId
3578 
    args.addressId = addressId
3579 
    args.write(self._oprot)
3580 
    self._oprot.writeMessageEnd()
3581 
    self._oprot.trans.flush()
3582 
 
3583 
  def recv_updateShipmentAddress(self, ):
3584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3585 
    if mtype == TMessageType.EXCEPTION:
3586 
      x = TApplicationException()
3587 
      x.read(self._iprot)
3588 
      self._iprot.readMessageEnd()
3589 
      raise x
3590 
    result = updateShipmentAddress_result()
3591 
    result.read(self._iprot)
3592 
    self._iprot.readMessageEnd()
3593 
    if result.ex is not None:
3594 
      raise result.ex
3595 
    return
3596 
 
4285 rajveer 3597 
  def acceptOrdersForItemId(self, itemId, inventory):
3598 
    """
3599 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3600 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3601 
 
4285 rajveer 3602 
    Parameters:
3603 
     - itemId
3604 
     - inventory
3605 
    """
3606 
    self.send_acceptOrdersForItemId(itemId, inventory)
3607 
    return self.recv_acceptOrdersForItemId()
3608 
 
3609 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3610 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3611 
    args = acceptOrdersForItemId_args()
3612 
    args.itemId = itemId
3613 
    args.inventory = inventory
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_acceptOrdersForItemId(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = acceptOrdersForItemId_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
3628 
    if result.success is not None:
3629 
      return result.success
3630 
    if result.ex is not None:
3631 
      raise result.ex
3632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3633 
 
4369 rajveer 3634 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3635 
    """
3636 
    Parameters:
3637 
     - vendorId
3638 
     - itemId
3639 
     - quantity
3640 
     - estimate
4369 rajveer 3641 
     - isReminder
4303 rajveer 3642 
    """
4369 rajveer 3643 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3644 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3645 
 
4369 rajveer 3646 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3647 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3648 
    args = markOrdersAsPORaised_args()
3649 
    args.vendorId = vendorId
3650 
    args.itemId = itemId
3651 
    args.quantity = quantity
3652 
    args.estimate = estimate
4369 rajveer 3653 
    args.isReminder = isReminder
4303 rajveer 3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_markOrdersAsPORaised(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = markOrdersAsPORaised_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
3668 
    if result.ex is not None:
3669 
      raise result.ex
3670 
    return
3671 
 
4369 rajveer 3672 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3673 
    """
3674 
    Parameters:
3675 
     - vendorId
3676 
     - itemId
3677 
     - quantity
3678 
     - estimate
4369 rajveer 3679 
     - isReminder
4303 rajveer 3680 
    """
4369 rajveer 3681 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3682 
    self.recv_markOrdersAsReversalInitiated()
3683 
 
4369 rajveer 3684 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3685 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3686 
    args = markOrdersAsReversalInitiated_args()
3687 
    args.vendorId = vendorId
3688 
    args.itemId = itemId
3689 
    args.quantity = quantity
3690 
    args.estimate = estimate
4369 rajveer 3691 
    args.isReminder = isReminder
4303 rajveer 3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_markOrdersAsReversalInitiated(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = markOrdersAsReversalInitiated_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
3706 
    if result.ex is not None:
3707 
      raise result.ex
3708 
    return
3709 
 
4369 rajveer 3710 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3711 
    """
3712 
    Parameters:
3713 
     - vendorId
3714 
     - itemId
3715 
     - quantity
3716 
     - estimate
4369 rajveer 3717 
     - isReminder
4303 rajveer 3718 
    """
4369 rajveer 3719 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3720 
    self.recv_markOrdersAsNotAvailabke()
3721 
 
4369 rajveer 3722 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3723 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3724 
    args = markOrdersAsNotAvailabke_args()
3725 
    args.vendorId = vendorId
3726 
    args.itemId = itemId
3727 
    args.quantity = quantity
3728 
    args.estimate = estimate
4369 rajveer 3729 
    args.isReminder = isReminder
4303 rajveer 3730 
    args.write(self._oprot)
3731 
    self._oprot.writeMessageEnd()
3732 
    self._oprot.trans.flush()
3733 
 
3734 
  def recv_markOrdersAsNotAvailabke(self, ):
3735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3736 
    if mtype == TMessageType.EXCEPTION:
3737 
      x = TApplicationException()
3738 
      x.read(self._iprot)
3739 
      self._iprot.readMessageEnd()
3740 
      raise x
3741 
    result = markOrdersAsNotAvailabke_result()
3742 
    result.read(self._iprot)
3743 
    self._iprot.readMessageEnd()
3744 
    if result.ex is not None:
3745 
      raise result.ex
3746 
    return
3747 
 
4369 rajveer 3748 
  def markOrdersAsTimeout(self, vendorId):
3749 
    """
3750 
    Parameters:
3751 
     - vendorId
3752 
    """
3753 
    self.send_markOrdersAsTimeout(vendorId)
3754 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3755 
 
4369 rajveer 3756 
  def send_markOrdersAsTimeout(self, vendorId):
3757 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3758 
    args = markOrdersAsTimeout_args()
3759 
    args.vendorId = vendorId
3760 
    args.write(self._oprot)
3761 
    self._oprot.writeMessageEnd()
3762 
    self._oprot.trans.flush()
3763 
 
3764 
  def recv_markOrdersAsTimeout(self, ):
3765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3766 
    if mtype == TMessageType.EXCEPTION:
3767 
      x = TApplicationException()
3768 
      x.read(self._iprot)
3769 
      self._iprot.readMessageEnd()
3770 
      raise x
3771 
    result = markOrdersAsTimeout_result()
3772 
    result.read(self._iprot)
3773 
    self._iprot.readMessageEnd()
3774 
    if result.success is not None:
3775 
      return result.success
3776 
    if result.ex is not None:
3777 
      raise result.ex
3778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3779 
 
4386 anupam.sin 3780 
  def getOrderForAwb(self, awb):
3781 
    """
3782 
    Returns the order corresponding to an AWB number
4369 rajveer 3783 
 
4386 anupam.sin 3784 
    Parameters:
3785 
     - awb
3786 
    """
3787 
    self.send_getOrderForAwb(awb)
3788 
    return self.recv_getOrderForAwb()
3789 
 
3790 
  def send_getOrderForAwb(self, awb):
3791 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3792 
    args = getOrderForAwb_args()
3793 
    args.awb = awb
3794 
    args.write(self._oprot)
3795 
    self._oprot.writeMessageEnd()
3796 
    self._oprot.trans.flush()
3797 
 
3798 
  def recv_getOrderForAwb(self, ):
3799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3800 
    if mtype == TMessageType.EXCEPTION:
3801 
      x = TApplicationException()
3802 
      x.read(self._iprot)
3803 
      self._iprot.readMessageEnd()
3804 
      raise x
3805 
    result = getOrderForAwb_result()
3806 
    result.read(self._iprot)
3807 
    self._iprot.readMessageEnd()
3808 
    if result.success is not None:
3809 
      return result.success
3810 
    if result.ex is not None:
3811 
      raise result.ex
3812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3813 
 
4506 phani.kuma 3814 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3815 
    """
3816 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3817 
 
4506 phani.kuma 3818 
    Parameters:
3819 
     - logistics_provider_id
3820 
     - order_status
3821 
    """
3822 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3823 
    return self.recv_getOrdersForProviderForStatus()
3824 
 
3825 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3826 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3827 
    args = getOrdersForProviderForStatus_args()
3828 
    args.logistics_provider_id = logistics_provider_id
3829 
    args.order_status = order_status
3830 
    args.write(self._oprot)
3831 
    self._oprot.writeMessageEnd()
3832 
    self._oprot.trans.flush()
3833 
 
3834 
  def recv_getOrdersForProviderForStatus(self, ):
3835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3836 
    if mtype == TMessageType.EXCEPTION:
3837 
      x = TApplicationException()
3838 
      x.read(self._iprot)
3839 
      self._iprot.readMessageEnd()
3840 
      raise x
3841 
    result = getOrdersForProviderForStatus_result()
3842 
    result.read(self._iprot)
3843 
    self._iprot.readMessageEnd()
3844 
    if result.success is not None:
3845 
      return result.success
3846 
    if result.ex is not None:
3847 
      raise result.ex
3848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3849 
 
4600 varun.gupt 3850 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3851 
    """
3852 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3853 
 
4600 varun.gupt 3854 
    Parameters:
3855 
     - vendorId
3856 
     - billingDateFrom
3857 
     - billingDateTo
3858 
    """
3859 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3860 
    return self.recv_getBilledOrdersForVendor()
3861 
 
3862 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3863 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3864 
    args = getBilledOrdersForVendor_args()
3865 
    args.vendorId = vendorId
3866 
    args.billingDateFrom = billingDateFrom
3867 
    args.billingDateTo = billingDateTo
3868 
    args.write(self._oprot)
3869 
    self._oprot.writeMessageEnd()
3870 
    self._oprot.trans.flush()
3871 
 
3872 
  def recv_getBilledOrdersForVendor(self, ):
3873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3874 
    if mtype == TMessageType.EXCEPTION:
3875 
      x = TApplicationException()
3876 
      x.read(self._iprot)
3877 
      self._iprot.readMessageEnd()
3878 
      raise x
3879 
    result = getBilledOrdersForVendor_result()
3880 
    result.read(self._iprot)
3881 
    self._iprot.readMessageEnd()
3882 
    if result.success is not None:
3883 
      return result.success
3884 
    if result.ex is not None:
3885 
      raise result.ex
3886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3887 
 
3888 
  def saveBluedartSettlements(self, mapAWBAndAmount):
3889 
    """
3890 
    Parameters:
3891 
     - mapAWBAndAmount
3892 
    """
3893 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
3894 
    self.recv_saveBluedartSettlements()
3895 
 
3896 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
3897 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
3898 
    args = saveBluedartSettlements_args()
3899 
    args.mapAWBAndAmount = mapAWBAndAmount
3900 
    args.write(self._oprot)
3901 
    self._oprot.writeMessageEnd()
3902 
    self._oprot.trans.flush()
3903 
 
3904 
  def recv_saveBluedartSettlements(self, ):
3905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3906 
    if mtype == TMessageType.EXCEPTION:
3907 
      x = TApplicationException()
3908 
      x.read(self._iprot)
3909 
      self._iprot.readMessageEnd()
3910 
      raise x
3911 
    result = saveBluedartSettlements_result()
3912 
    result.read(self._iprot)
3913 
    self._iprot.readMessageEnd()
3914 
    if result.ex is not None:
3915 
      raise result.ex
3916 
    return
3917 
 
3918 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3919 
    """
3920 
    Parameters:
3921 
     - settlementDate
3922 
     - paymentGatewayId
3923 
     - paymentId
3924 
     - serviceTax
3925 
     - otherCharges
3926 
     - netCollection
3927 
    """
3928 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
3929 
    self.recv_savePaymentSettlements()
3930 
 
3931 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
3932 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
3933 
    args = savePaymentSettlements_args()
3934 
    args.settlementDate = settlementDate
3935 
    args.paymentGatewayId = paymentGatewayId
3936 
    args.paymentId = paymentId
3937 
    args.serviceTax = serviceTax
3938 
    args.otherCharges = otherCharges
3939 
    args.netCollection = netCollection
3940 
    args.write(self._oprot)
3941 
    self._oprot.writeMessageEnd()
3942 
    self._oprot.trans.flush()
3943 
 
3944 
  def recv_savePaymentSettlements(self, ):
3945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3946 
    if mtype == TMessageType.EXCEPTION:
3947 
      x = TApplicationException()
3948 
      x.read(self._iprot)
3949 
      self._iprot.readMessageEnd()
3950 
      raise x
3951 
    result = savePaymentSettlements_result()
3952 
    result.read(self._iprot)
3953 
    self._iprot.readMessageEnd()
3954 
    if result.ex is not None:
3955 
      raise result.ex
3956 
    return
3957 
 
3958 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3959 
    """
3960 
    Parameters:
3961 
     - settlementId
3962 
     - settlementDate
3963 
     - transactionDateFrom
3964 
     - transactionDateTo
3965 
     - amount
3966 
    """
3967 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
3968 
    self.recv_saveEBSSettlementSummary()
3969 
 
3970 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
3971 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
3972 
    args = saveEBSSettlementSummary_args()
3973 
    args.settlementId = settlementId
3974 
    args.settlementDate = settlementDate
3975 
    args.transactionDateFrom = transactionDateFrom
3976 
    args.transactionDateTo = transactionDateTo
3977 
    args.amount = amount
3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_saveEBSSettlementSummary(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = saveEBSSettlementSummary_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    if result.ex is not None:
3993 
      raise result.ex
3994 
    return
3995 
 
3996 
  def getSettlementForPaymentId(self, paymentId):
3997 
    """
3998 
    Parameters:
3999 
     - paymentId
4000 
    """
4001 
    self.send_getSettlementForPaymentId(paymentId)
4002 
    return self.recv_getSettlementForPaymentId()
4003 
 
4004 
  def send_getSettlementForPaymentId(self, paymentId):
4005 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4006 
    args = getSettlementForPaymentId_args()
4007 
    args.paymentId = paymentId
4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_getSettlementForPaymentId(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = getSettlementForPaymentId_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
4022 
    if result.success is not None:
4023 
      return result.success
4024 
    if result.ex is not None:
4025 
      raise result.ex
4026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4027 
 
4028 
  def getEBSSettlementSummaries(self, ):
4029 
    self.send_getEBSSettlementSummaries()
4030 
    return self.recv_getEBSSettlementSummaries()
4031 
 
4032 
  def send_getEBSSettlementSummaries(self, ):
4033 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4034 
    args = getEBSSettlementSummaries_args()
4035 
    args.write(self._oprot)
4036 
    self._oprot.writeMessageEnd()
4037 
    self._oprot.trans.flush()
4038 
 
4039 
  def recv_getEBSSettlementSummaries(self, ):
4040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4041 
    if mtype == TMessageType.EXCEPTION:
4042 
      x = TApplicationException()
4043 
      x.read(self._iprot)
4044 
      self._iprot.readMessageEnd()
4045 
      raise x
4046 
    result = getEBSSettlementSummaries_result()
4047 
    result.read(self._iprot)
4048 
    self._iprot.readMessageEnd()
4049 
    if result.success is not None:
4050 
      return result.success
4051 
    if result.ex is not None:
4052 
      raise result.ex
4053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4054 
 
4055 
  def markEBSSettlementUploaded(self, settlementId):
4056 
    """
4057 
    Parameters:
4058 
     - settlementId
4059 
    """
4060 
    self.send_markEBSSettlementUploaded(settlementId)
4061 
    self.recv_markEBSSettlementUploaded()
4062 
 
4063 
  def send_markEBSSettlementUploaded(self, settlementId):
4064 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4065 
    args = markEBSSettlementUploaded_args()
4066 
    args.settlementId = settlementId
4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_markEBSSettlementUploaded(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = markEBSSettlementUploaded_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
4081 
    if result.ex is not None:
4082 
      raise result.ex
4083 
    return
4084 
 
4085 
  def getEBSSettlementDate(self, settlementId):
4086 
    """
4087 
    Parameters:
4088 
     - settlementId
4089 
    """
4090 
    self.send_getEBSSettlementDate(settlementId)
4091 
    return self.recv_getEBSSettlementDate()
4092 
 
4093 
  def send_getEBSSettlementDate(self, settlementId):
4094 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4095 
    args = getEBSSettlementDate_args()
4096 
    args.settlementId = settlementId
4097 
    args.write(self._oprot)
4098 
    self._oprot.writeMessageEnd()
4099 
    self._oprot.trans.flush()
4100 
 
4101 
  def recv_getEBSSettlementDate(self, ):
4102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4103 
    if mtype == TMessageType.EXCEPTION:
4104 
      x = TApplicationException()
4105 
      x.read(self._iprot)
4106 
      self._iprot.readMessageEnd()
4107 
      raise x
4108 
    result = getEBSSettlementDate_result()
4109 
    result.read(self._iprot)
4110 
    self._iprot.readMessageEnd()
4111 
    if result.success is not None:
4112 
      return result.success
4113 
    if result.ex is not None:
4114 
      raise result.ex
4115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4116 
 
4117 
 
3376 rajveer 4118 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4119 
  def __init__(self, handler):
3376 rajveer 4120 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4121 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4122 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4123 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4124 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4125 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4126 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4127 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4128 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4129 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4130 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4131 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4132 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4133 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4134 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4135 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4136 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4137 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4138 
    self._processMap["createOrder"] = Processor.process_createOrder
4139 
    self._processMap["getOrder"] = Processor.process_getOrder
4140 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4141 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4142 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4143 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4144 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4145 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4146 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4147 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4148 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4149 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4150 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4151 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4152 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4153 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4154 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4155 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4156 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4157 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4158 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4159 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4160 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4161 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4162 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4163 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4164 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4165 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4166 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4167 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4168 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4169 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4170 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4171 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4172 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4173 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4174 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4175 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4176 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4177 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4178 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4179 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4180 
    self._processMap["changeItem"] = Processor.process_changeItem
4181 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4182 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4183 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4184 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4185 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4186 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4187 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4188 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4189 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4190 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4191 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4192 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4193 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4194 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4195 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4196 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4197 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4198 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 4199 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4200 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4201 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4202 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4203 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4204 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4205 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4206 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4207 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4208 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4209 
 
4210 
  def process(self, iprot, oprot):
4211 
    (name, type, seqid) = iprot.readMessageBegin()
4212 
    if name not in self._processMap:
4213 
      iprot.skip(TType.STRUCT)
4214 
      iprot.readMessageEnd()
4215 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4216 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4217 
      x.write(oprot)
4218 
      oprot.writeMessageEnd()
4219 
      oprot.trans.flush()
4220 
      return
4221 
    else:
4222 
      self._processMap[name](self, seqid, iprot, oprot)
4223 
    return True
4224 
 
4225 
  def process_createTransaction(self, seqid, iprot, oprot):
4226 
    args = createTransaction_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = createTransaction_result()
4230 
    try:
132 ashish 4231 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4232 
    except TransactionServiceException, ex:
4233 
      result.ex = ex
4234 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getTransaction(self, seqid, iprot, oprot):
4240 
    args = getTransaction_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getTransaction_result()
4244 
    try:
4245 
      result.success = self._handler.getTransaction(args.id)
4246 
    except TransactionServiceException, ex:
4247 
      result.ex = ex
4248 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
4253 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4254 
    args = getTransactionsForCustomer_args()
4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
4257 
    result = getTransactionsForCustomer_result()
4258 
    try:
4259 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4260 
    except TransactionServiceException, ex:
4261 
      result.ex = ex
4262 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
4266 
 
132 ashish 4267 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4268 
    args = getTransactionsForShoppingCartId_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = getTransactionsForShoppingCartId_result()
4272 
    try:
4273 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4274 
    except TransactionServiceException, ex:
4275 
      result.ex = ex
4276 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
94 ashish 4281 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4282 
    args = getTransactionStatus_args()
4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
4285 
    result = getTransactionStatus_result()
4286 
    try:
4287 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4288 
    except TransactionServiceException, ex:
4289 
      result.ex = ex
4290 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
4295 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4296 
    args = changeTransactionStatus_args()
4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
4299 
    result = changeTransactionStatus_result()
4300 
    try:
4301 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4302 
    except TransactionServiceException, ex:
4303 
      result.ex = ex
4304 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
4308 
 
1398 varun.gupt 4309 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4310 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
1398 varun.gupt 4313 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4314 
    try:
1398 varun.gupt 4315 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4316 
    except TransactionServiceException, ex:
4317 
      result.ex = ex
1398 varun.gupt 4318 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4319 
    result.write(oprot)
4320 
    oprot.writeMessageEnd()
4321 
    oprot.trans.flush()
4322 
 
483 rajveer 4323 
  def process_getAllOrders(self, seqid, iprot, oprot):
4324 
    args = getAllOrders_args()
94 ashish 4325 
    args.read(iprot)
4326 
    iprot.readMessageEnd()
483 rajveer 4327 
    result = getAllOrders_result()
94 ashish 4328 
    try:
483 rajveer 4329 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4330 
    except TransactionServiceException, ex:
4331 
      result.ex = ex
483 rajveer 4332 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4333 
    result.write(oprot)
4334 
    oprot.writeMessageEnd()
4335 
    oprot.trans.flush()
4336 
 
4133 chandransh 4337 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4338 
    args = getOrdersInBatch_args()
4339 
    args.read(iprot)
4340 
    iprot.readMessageEnd()
4341 
    result = getOrdersInBatch_result()
4342 
    try:
4343 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4344 
    except TransactionServiceException, ex:
4345 
      result.ex = ex
4346 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4347 
    result.write(oprot)
4348 
    oprot.writeMessageEnd()
4349 
    oprot.trans.flush()
4350 
 
4351 
  def process_getOrderCount(self, seqid, iprot, oprot):
4352 
    args = getOrderCount_args()
4353 
    args.read(iprot)
4354 
    iprot.readMessageEnd()
4355 
    result = getOrderCount_result()
4356 
    try:
4357 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4358 
    except TransactionServiceException, ex:
4359 
      result.ex = ex
4360 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4361 
    result.write(oprot)
4362 
    oprot.writeMessageEnd()
4363 
    oprot.trans.flush()
4364 
 
999 varun.gupt 4365 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4366 
    args = getOrdersByBillingDate_args()
4367 
    args.read(iprot)
4368 
    iprot.readMessageEnd()
4369 
    result = getOrdersByBillingDate_result()
4370 
    try:
4371 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4372 
    except TransactionServiceException, ex:
4373 
      result.ex = ex
4374 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4375 
    result.write(oprot)
4376 
    oprot.writeMessageEnd()
4377 
    oprot.trans.flush()
4378 
 
3427 chandransh 4379 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4380 
    args = getOrdersByShippingDate_args()
4381 
    args.read(iprot)
4382 
    iprot.readMessageEnd()
4383 
    result = getOrdersByShippingDate_result()
4384 
    try:
3451 chandransh 4385 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4386 
    except TransactionServiceException, ex:
4387 
      result.ex = ex
4388 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4389 
    result.write(oprot)
4390 
    oprot.writeMessageEnd()
4391 
    oprot.trans.flush()
4392 
 
1382 varun.gupt 4393 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4394 
    args = getReturnableOrdersForCustomer_args()
4395 
    args.read(iprot)
4396 
    iprot.readMessageEnd()
4397 
    result = getReturnableOrdersForCustomer_result()
4398 
    try:
4399 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4400 
    except TransactionServiceException, ex:
4401 
      result.ex = ex
4402 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
4407 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4408 
    args = getCancellableOrdersForCustomer_args()
4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
4411 
    result = getCancellableOrdersForCustomer_result()
4412 
    try:
4413 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4414 
    except TransactionServiceException, ex:
4415 
      result.ex = ex
4416 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
4420 
 
483 rajveer 4421 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4422 
    args = changeOrderStatus_args()
94 ashish 4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
483 rajveer 4425 
    result = changeOrderStatus_result()
94 ashish 4426 
    try:
483 rajveer 4427 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4428 
    except TransactionServiceException, ex:
4429 
      result.ex = ex
483 rajveer 4430 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
483 rajveer 4435 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4436 
    args = getOrdersForTransaction_args()
94 ashish 4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
483 rajveer 4439 
    result = getOrdersForTransaction_result()
94 ashish 4440 
    try:
1528 ankur.sing 4441 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4442 
    except TransactionServiceException, ex:
4443 
      result.ex = ex
483 rajveer 4444 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
4448 
 
483 rajveer 4449 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4450 
    args = getOrdersForCustomer_args()
94 ashish 4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
483 rajveer 4453 
    result = getOrdersForCustomer_result()
94 ashish 4454 
    try:
3014 chandransh 4455 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4456 
    except TransactionServiceException, ex:
4457 
      result.ex = ex
483 rajveer 4458 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
483 rajveer 4463 
  def process_createOrder(self, seqid, iprot, oprot):
4464 
    args = createOrder_args()
94 ashish 4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
483 rajveer 4467 
    result = createOrder_result()
94 ashish 4468 
    try:
483 rajveer 4469 
      result.success = self._handler.createOrder(args.order)
94 ashish 4470 
    except TransactionServiceException, ex:
4471 
      result.ex = ex
483 rajveer 4472 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
483 rajveer 4477 
  def process_getOrder(self, seqid, iprot, oprot):
4478 
    args = getOrder_args()
94 ashish 4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
483 rajveer 4481 
    result = getOrder_result()
94 ashish 4482 
    try:
483 rajveer 4483 
      result.success = self._handler.getOrder(args.id)
94 ashish 4484 
    except TransactionServiceException, ex:
4485 
      result.ex = ex
483 rajveer 4486 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4487 
    result.write(oprot)
4488 
    oprot.writeMessageEnd()
4489 
    oprot.trans.flush()
4490 
 
483 rajveer 4491 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4492 
    args = getLineItemsForOrder_args()
94 ashish 4493 
    args.read(iprot)
4494 
    iprot.readMessageEnd()
483 rajveer 4495 
    result = getLineItemsForOrder_result()
94 ashish 4496 
    try:
483 rajveer 4497 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4498 
    except TransactionServiceException, ex:
4499 
      result.ex = ex
483 rajveer 4500 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
1528 ankur.sing 4505 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4506 
    args = getOrderForCustomer_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = getOrderForCustomer_result()
4510 
    try:
4511 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4512 
    except TransactionServiceException, ex:
4513 
      result.ex = ex
4514 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4515 
    result.write(oprot)
4516 
    oprot.writeMessageEnd()
4517 
    oprot.trans.flush()
4518 
 
3064 chandransh 4519 
  def process_getAlerts(self, seqid, iprot, oprot):
4520 
    args = getAlerts_args()
4521 
    args.read(iprot)
4522 
    iprot.readMessageEnd()
4523 
    result = getAlerts_result()
4444 rajveer 4524 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4525 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4526 
    result.write(oprot)
4527 
    oprot.writeMessageEnd()
4528 
    oprot.trans.flush()
4529 
 
4394 rajveer 4530 
  def process_addAlert(self, seqid, iprot, oprot):
4531 
    args = addAlert_args()
3064 chandransh 4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
4394 rajveer 4534 
    result = addAlert_result()
4444 rajveer 4535 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4536 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
4444 rajveer 4541 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4542 
    args = markAlertsAsSeen_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = markAlertsAsSeen_result()
4546 
    self._handler.markAlertsAsSeen(args.warehouseId)
4547 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
4551 
 
3064 chandransh 4552 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4553 
    args = getValidOrderCount_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = getValidOrderCount_result()
4557 
    result.success = self._handler.getValidOrderCount()
4558 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4559 
    result.write(oprot)
4560 
    oprot.writeMessageEnd()
4561 
    oprot.trans.flush()
4562 
 
4563 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4564 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4565 
    args.read(iprot)
4566 
    iprot.readMessageEnd()
4567 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4568 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4569 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
4574 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4575 
    args = getValidOrdersAmountRange_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = getValidOrdersAmountRange_result()
4579 
    result.success = self._handler.getValidOrdersAmountRange()
4580 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
4585 
  def process_getValidOrders(self, seqid, iprot, oprot):
4586 
    args = getValidOrders_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = getValidOrders_result()
4590 
    result.success = self._handler.getValidOrders(args.limit)
4591 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
4595 
 
1220 chandransh 4596 
  def process_batchOrders(self, seqid, iprot, oprot):
4597 
    args = batchOrders_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = batchOrders_result()
4601 
    try:
4602 
      result.success = self._handler.batchOrders(args.warehouseId)
4603 
    except TransactionServiceException, ex:
4604 
      result.ex = ex
4605 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4606 
    result.write(oprot)
4607 
    oprot.writeMessageEnd()
4608 
    oprot.trans.flush()
4609 
 
1208 chandransh 4610 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4611 
    args = markOrderAsOutOfStock_args()
4612 
    args.read(iprot)
4613 
    iprot.readMessageEnd()
4614 
    result = markOrderAsOutOfStock_result()
4615 
    try:
4616 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4617 
    except TransactionServiceException, ex:
4618 
      result.ex = ex
4619 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
3064 chandransh 4624 
  def process_verifyOrder(self, seqid, iprot, oprot):
4625 
    args = verifyOrder_args()
759 chandransh 4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
3064 chandransh 4628 
    result = verifyOrder_result()
759 chandransh 4629 
    try:
3064 chandransh 4630 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4631 
    except TransactionServiceException, ex:
4632 
      result.ex = ex
3064 chandransh 4633 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4634 
    result.write(oprot)
4635 
    oprot.writeMessageEnd()
4636 
    oprot.trans.flush()
4637 
 
3064 chandransh 4638 
  def process_acceptOrder(self, seqid, iprot, oprot):
4639 
    args = acceptOrder_args()
1113 chandransh 4640 
    args.read(iprot)
4641 
    iprot.readMessageEnd()
3064 chandransh 4642 
    result = acceptOrder_result()
1113 chandransh 4643 
    try:
3064 chandransh 4644 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4645 
    except TransactionServiceException, ex:
4646 
      result.ex = ex
3064 chandransh 4647 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4648 
    result.write(oprot)
4649 
    oprot.writeMessageEnd()
4650 
    oprot.trans.flush()
4651 
 
3064 chandransh 4652 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4653 
    args = addBillingDetails_args()
1135 chandransh 4654 
    args.read(iprot)
4655 
    iprot.readMessageEnd()
3064 chandransh 4656 
    result = addBillingDetails_result()
1135 chandransh 4657 
    try:
4283 anupam.sin 4658 
      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 4659 
    except TransactionServiceException, ex:
4660 
      result.ex = ex
3064 chandransh 4661 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4579 rajveer 4666 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4667 
    args = addInvoiceNumber_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = addInvoiceNumber_result()
4671 
    try:
4672 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4673 
    except TransactionServiceException, ex:
4674 
      result.ex = ex
4675 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4676 
    result.write(oprot)
4677 
    oprot.writeMessageEnd()
4678 
    oprot.trans.flush()
4679 
 
3064 chandransh 4680 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4681 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4682 
    args.read(iprot)
4683 
    iprot.readMessageEnd()
3064 chandransh 4684 
    result = markOrdersAsManifested_result()
4685 
    try:
4686 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4687 
    except TransactionServiceException, ex:
4688 
      result.ex = ex
4689 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4690 
    result.write(oprot)
4691 
    oprot.writeMessageEnd()
4692 
    oprot.trans.flush()
4693 
 
4410 rajveer 4694 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4695 
    args = markOrdersAsShippedFromWarehouse_args()
4696 
    args.read(iprot)
4697 
    iprot.readMessageEnd()
4698 
    result = markOrdersAsShippedFromWarehouse_result()
4699 
    try:
4700 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4701 
    except TransactionServiceException, ex:
4702 
      result.ex = ex
4703 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4704 
    result.write(oprot)
4705 
    oprot.writeMessageEnd()
4706 
    oprot.trans.flush()
4707 
 
3064 chandransh 4708 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4709 
    args = markOrdersAsPickedUp_args()
304 ashish 4710 
    args.read(iprot)
4711 
    iprot.readMessageEnd()
3064 chandransh 4712 
    result = markOrdersAsPickedUp_result()
4713 
    try:
4714 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4715 
    except TransactionServiceException, ex:
4716 
      result.ex = ex
4717 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4718 
    result.write(oprot)
4719 
    oprot.writeMessageEnd()
4720 
    oprot.trans.flush()
94 ashish 4721 
 
3064 chandransh 4722 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4723 
    args = markOrdersAsDelivered_args()
304 ashish 4724 
    args.read(iprot)
4725 
    iprot.readMessageEnd()
3064 chandransh 4726 
    result = markOrdersAsDelivered_result()
4727 
    try:
4728 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4729 
    except TransactionServiceException, ex:
4730 
      result.ex = ex
4731 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4732 
    result.write(oprot)
4733 
    oprot.writeMessageEnd()
4734 
    oprot.trans.flush()
4735 
 
3064 chandransh 4736 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4737 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4738 
    args.read(iprot)
4739 
    iprot.readMessageEnd()
3064 chandransh 4740 
    result = markOrdersAsFailed_result()
4741 
    try:
4742 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4743 
    except TransactionServiceException, ex:
4744 
      result.ex = ex
4745 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4746 
    result.write(oprot)
4747 
    oprot.writeMessageEnd()
4748 
    oprot.trans.flush()
304 ashish 4749 
 
3064 chandransh 4750 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4751 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4752 
    args.read(iprot)
4753 
    iprot.readMessageEnd()
3064 chandransh 4754 
    result = updateNonDeliveryReason_result()
4755 
    try:
4581 phani.kuma 4756 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4757 
    except TransactionServiceException, ex:
4758 
      result.ex = ex
4759 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
1596 ankur.sing 4763 
 
3064 chandransh 4764 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4765 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
3064 chandransh 4768 
    result = getUndeliveredOrders_result()
4769 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4770 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
2536 chandransh 4775 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4776 
    args = toggleDOAFlag_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = toggleDOAFlag_result()
4780 
    try:
4781 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4782 
    except TransactionServiceException, ex:
4783 
      result.ex = ex
4784 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4785 
    result.write(oprot)
4786 
    oprot.writeMessageEnd()
4787 
    oprot.trans.flush()
1886 ankur.sing 4788 
 
4454 rajveer 4789 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4790 
    args = markOrderDoaRequestReceived_args()
4791 
    args.read(iprot)
4792 
    iprot.readMessageEnd()
4793 
    result = markOrderDoaRequestReceived_result()
4794 
    try:
4795 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4796 
    except TransactionServiceException, ex:
4797 
      result.ex = ex
4798 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
4803 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4804 
    args = markOrderDoaRequestAuthorized_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = markOrderDoaRequestAuthorized_result()
4808 
    try:
4809 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4810 
    except TransactionServiceException, ex:
4811 
      result.ex = ex
4812 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
4488 rajveer 4817 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4818 
    args = markOrderReturnRequestReceived_args()
4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4821 
    result = markOrderReturnRequestReceived_result()
4822 
    try:
4823 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4824 
    except TransactionServiceException, ex:
4825 
      result.ex = ex
4826 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4827 
    result.write(oprot)
4828 
    oprot.writeMessageEnd()
4829 
    oprot.trans.flush()
4830 
 
4831 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4832 
    args = markOrderReturnRequestAuthorized_args()
4833 
    args.read(iprot)
4834 
    iprot.readMessageEnd()
4835 
    result = markOrderReturnRequestAuthorized_result()
4836 
    try:
4837 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4838 
    except TransactionServiceException, ex:
4839 
      result.ex = ex
4840 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
4844 
 
2536 chandransh 4845 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4846 
    args = requestPickupNumber_args()
4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
4849 
    result = requestPickupNumber_result()
4850 
    try:
4579 rajveer 4851 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4852 
    except TransactionServiceException, ex:
4853 
      result.ex = ex
4854 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4855 
    result.write(oprot)
4856 
    oprot.writeMessageEnd()
4857 
    oprot.trans.flush()
4858 
 
4859 
  def process_authorizePickup(self, seqid, iprot, oprot):
4860 
    args = authorizePickup_args()
4861 
    args.read(iprot)
4862 
    iprot.readMessageEnd()
4863 
    result = authorizePickup_result()
4864 
    try:
4865 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4866 
    except TransactionServiceException, ex:
4867 
      result.ex = ex
4868 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4869 
    result.write(oprot)
4870 
    oprot.writeMessageEnd()
4871 
    oprot.trans.flush()
4872 
 
2764 chandransh 4873 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4874 
    args = markDoasAsPickedUp_args()
4875 
    args.read(iprot)
4876 
    iprot.readMessageEnd()
4877 
    result = markDoasAsPickedUp_result()
4878 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4879 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4880 
    result.write(oprot)
4881 
    oprot.writeMessageEnd()
4882 
    oprot.trans.flush()
4883 
 
2616 chandransh 4884 
  def process_receiveReturn(self, seqid, iprot, oprot):
4885 
    args = receiveReturn_args()
2591 chandransh 4886 
    args.read(iprot)
4887 
    iprot.readMessageEnd()
2616 chandransh 4888 
    result = receiveReturn_result()
2591 chandransh 4889 
    try:
4479 rajveer 4890 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4891 
    except TransactionServiceException, ex:
4892 
      result.ex = ex
2616 chandransh 4893 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4894 
    result.write(oprot)
4895 
    oprot.writeMessageEnd()
4896 
    oprot.trans.flush()
2536 chandransh 4897 
 
2591 chandransh 4898 
  def process_validateDoa(self, seqid, iprot, oprot):
4899 
    args = validateDoa_args()
4900 
    args.read(iprot)
4901 
    iprot.readMessageEnd()
4902 
    result = validateDoa_result()
4903 
    try:
4904 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4905 
    except TransactionServiceException, ex:
4906 
      result.ex = ex
4907 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4908 
    result.write(oprot)
4909 
    oprot.writeMessageEnd()
4910 
    oprot.trans.flush()
4911 
 
4495 rajveer 4912 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4913 
    args = validateReturnProduct_args()
4914 
    args.read(iprot)
4915 
    iprot.readMessageEnd()
4916 
    result = validateReturnProduct_result()
4917 
    try:
4918 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4919 
    except TransactionServiceException, ex:
4920 
      result.ex = ex
4921 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4922 
    result.write(oprot)
4923 
    oprot.writeMessageEnd()
4924 
    oprot.trans.flush()
4925 
 
2616 chandransh 4926 
  def process_reshipOrder(self, seqid, iprot, oprot):
4927 
    args = reshipOrder_args()
4928 
    args.read(iprot)
4929 
    iprot.readMessageEnd()
4930 
    result = reshipOrder_result()
4931 
    try:
4932 
      result.success = self._handler.reshipOrder(args.orderId)
4933 
    except TransactionServiceException, ex:
4934 
      result.ex = ex
4935 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
2591 chandransh 4939 
 
2616 chandransh 4940 
  def process_refundOrder(self, seqid, iprot, oprot):
4941 
    args = refundOrder_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = refundOrder_result()
4945 
    try:
3226 chandransh 4946 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4947 
    except TransactionServiceException, ex:
4948 
      result.ex = ex
4949 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
2690 chandransh 4954 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4955 
    args = getReturnOrders_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = getReturnOrders_result()
4959 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4960 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
2616 chandransh 4964 
 
2700 chandransh 4965 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4966 
    args = getReturnOrder_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = getReturnOrder_result()
4970 
    try:
4971 
      result.success = self._handler.getReturnOrder(args.id)
4972 
    except TransactionServiceException, ex:
4973 
      result.ex = ex
4974 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
4978 
 
2690 chandransh 4979 
  def process_processReturn(self, seqid, iprot, oprot):
4980 
    args = processReturn_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = processReturn_result()
4984 
    try:
4985 
      self._handler.processReturn(args.returnOrderId)
4986 
    except TransactionServiceException, ex:
4987 
      result.ex = ex
4988 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
2819 chandransh 4993 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4994 
    args = createPurchaseOrder_args()
4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
4997 
    result = createPurchaseOrder_result()
4998 
    try:
4999 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5000 
    except TransactionServiceException, ex:
5001 
      result.ex = ex
5002 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
2690 chandransh 5006 
 
3451 chandransh 5007 
  def process_updateWeight(self, seqid, iprot, oprot):
5008 
    args = updateWeight_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = updateWeight_result()
5012 
    try:
5013 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5014 
    except TransactionServiceException, ex:
5015 
      result.ex = ex
5016 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
2819 chandransh 5020 
 
3469 chandransh 5021 
  def process_changeItem(self, seqid, iprot, oprot):
5022 
    args = changeItem_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = changeItem_result()
5026 
    try:
5027 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5028 
    except TransactionServiceException, ex:
5029 
      result.ex = ex
5030 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
3451 chandransh 5034 
 
3469 chandransh 5035 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5036 
    args = shiftToWarehouse_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = shiftToWarehouse_result()
5040 
    try:
5041 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5042 
    except TransactionServiceException, ex:
5043 
      result.ex = ex
5044 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
3553 chandransh 5049 
  def process_addDelayReason(self, seqid, iprot, oprot):
5050 
    args = addDelayReason_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = addDelayReason_result()
5054 
    try:
3986 chandransh 5055 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 5056 
    except TransactionServiceException, ex:
5057 
      result.ex = ex
5058 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
3469 chandransh 5062 
 
3956 chandransh 5063 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5064 
    args = reconcileCodCollection_args()
5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
5067 
    result = reconcileCodCollection_result()
5068 
    try:
5069 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5070 
    except TransactionServiceException, ex:
5071 
      result.ex = ex
5072 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
3553 chandransh 5076 
 
4008 mandeep.dh 5077 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5078 
    args = getTransactionsRequiringExtraProcessing_args()
5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
5081 
    result = getTransactionsRequiringExtraProcessing_result()
5082 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5083 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5084 
    result.write(oprot)
5085 
    oprot.writeMessageEnd()
5086 
    oprot.trans.flush()
3956 chandransh 5087 
 
4008 mandeep.dh 5088 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5089 
    args = markTransactionAsProcessed_args()
5090 
    args.read(iprot)
5091 
    iprot.readMessageEnd()
5092 
    result = markTransactionAsProcessed_result()
5093 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5094 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5095 
    result.write(oprot)
5096 
    oprot.writeMessageEnd()
5097 
    oprot.trans.flush()
5098 
 
4018 chandransh 5099 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5100 
    args = getItemWiseRiskyOrdersCount_args()
5101 
    args.read(iprot)
5102 
    iprot.readMessageEnd()
5103 
    result = getItemWiseRiskyOrdersCount_result()
5104 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5105 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5106 
    result.write(oprot)
5107 
    oprot.writeMessageEnd()
5108 
    oprot.trans.flush()
4008 mandeep.dh 5109 
 
4295 varun.gupt 5110 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5111 
    args = getOrdersForItemIds_args()
5112 
    args.read(iprot)
5113 
    iprot.readMessageEnd()
5114 
    result = getOrdersForItemIds_result()
5115 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5116 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5117 
    result.write(oprot)
5118 
    oprot.writeMessageEnd()
5119 
    oprot.trans.flush()
5120 
 
4247 rajveer 5121 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5122 
    args = markOrderCancellationRequestReceived_args()
5123 
    args.read(iprot)
5124 
    iprot.readMessageEnd()
5125 
    result = markOrderCancellationRequestReceived_result()
5126 
    try:
5127 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5128 
    except TransactionServiceException, ex:
5129 
      result.ex = ex
5130 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5131 
    result.write(oprot)
5132 
    oprot.writeMessageEnd()
5133 
    oprot.trans.flush()
4018 chandransh 5134 
 
4247 rajveer 5135 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5136 
    args = markOrderCancellationRequestConfirmed_args()
5137 
    args.read(iprot)
5138 
    iprot.readMessageEnd()
5139 
    result = markOrderCancellationRequestConfirmed_result()
5140 
    try:
5141 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5142 
    except TransactionServiceException, ex:
5143 
      result.ex = ex
5144 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5145 
    result.write(oprot)
5146 
    oprot.writeMessageEnd()
5147 
    oprot.trans.flush()
5148 
 
5149 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5150 
    args = markOrderCancellationRequestDenied_args()
5151 
    args.read(iprot)
5152 
    iprot.readMessageEnd()
5153 
    result = markOrderCancellationRequestDenied_result()
5154 
    try:
5155 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5156 
    except TransactionServiceException, ex:
5157 
      result.ex = ex
5158 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
5162 
 
4258 rajveer 5163 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5164 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5165 
    args.read(iprot)
5166 
    iprot.readMessageEnd()
4258 rajveer 5167 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5168 
    try:
4258 rajveer 5169 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5170 
    except TransactionServiceException, ex:
5171 
      result.ex = ex
4258 rajveer 5172 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
5176 
 
4259 anupam.sin 5177 
  def process_refundTransaction(self, seqid, iprot, oprot):
5178 
    args = refundTransaction_args()
5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
5181 
    result = refundTransaction_result()
5182 
    try:
5183 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5184 
    except TransactionServiceException, ex:
5185 
      result.ex = ex
5186 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5187 
    result.write(oprot)
5188 
    oprot.writeMessageEnd()
5189 
    oprot.trans.flush()
4247 rajveer 5190 
 
4324 mandeep.dh 5191 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5192 
    args = updateShipmentAddress_args()
5193 
    args.read(iprot)
5194 
    iprot.readMessageEnd()
5195 
    result = updateShipmentAddress_result()
5196 
    try:
5197 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5198 
    except TransactionServiceException, ex:
5199 
      result.ex = ex
5200 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
5204 
 
4285 rajveer 5205 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5206 
    args = acceptOrdersForItemId_args()
5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
5209 
    result = acceptOrdersForItemId_result()
5210 
    try:
5211 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5212 
    except TransactionServiceException, ex:
5213 
      result.ex = ex
5214 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5215 
    result.write(oprot)
5216 
    oprot.writeMessageEnd()
5217 
    oprot.trans.flush()
4259 anupam.sin 5218 
 
4303 rajveer 5219 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5220 
    args = markOrdersAsPORaised_args()
5221 
    args.read(iprot)
5222 
    iprot.readMessageEnd()
5223 
    result = markOrdersAsPORaised_result()
5224 
    try:
4369 rajveer 5225 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5226 
    except TransactionServiceException, ex:
5227 
      result.ex = ex
5228 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5229 
    result.write(oprot)
5230 
    oprot.writeMessageEnd()
5231 
    oprot.trans.flush()
4285 rajveer 5232 
 
4303 rajveer 5233 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5234 
    args = markOrdersAsReversalInitiated_args()
5235 
    args.read(iprot)
5236 
    iprot.readMessageEnd()
5237 
    result = markOrdersAsReversalInitiated_result()
5238 
    try:
4369 rajveer 5239 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5240 
    except TransactionServiceException, ex:
5241 
      result.ex = ex
5242 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5243 
    result.write(oprot)
5244 
    oprot.writeMessageEnd()
5245 
    oprot.trans.flush()
5246 
 
5247 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5248 
    args = markOrdersAsNotAvailabke_args()
5249 
    args.read(iprot)
5250 
    iprot.readMessageEnd()
5251 
    result = markOrdersAsNotAvailabke_result()
5252 
    try:
4369 rajveer 5253 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5254 
    except TransactionServiceException, ex:
5255 
      result.ex = ex
5256 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5257 
    result.write(oprot)
5258 
    oprot.writeMessageEnd()
5259 
    oprot.trans.flush()
5260 
 
4369 rajveer 5261 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5262 
    args = markOrdersAsTimeout_args()
5263 
    args.read(iprot)
5264 
    iprot.readMessageEnd()
5265 
    result = markOrdersAsTimeout_result()
5266 
    try:
5267 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5268 
    except TransactionServiceException, ex:
5269 
      result.ex = ex
5270 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
4303 rajveer 5274 
 
4386 anupam.sin 5275 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5276 
    args = getOrderForAwb_args()
5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
5279 
    result = getOrderForAwb_result()
5280 
    try:
5281 
      result.success = self._handler.getOrderForAwb(args.awb)
5282 
    except TransactionServiceException, ex:
5283 
      result.ex = ex
5284 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5285 
    result.write(oprot)
5286 
    oprot.writeMessageEnd()
5287 
    oprot.trans.flush()
4369 rajveer 5288 
 
4506 phani.kuma 5289 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5290 
    args = getOrdersForProviderForStatus_args()
5291 
    args.read(iprot)
5292 
    iprot.readMessageEnd()
5293 
    result = getOrdersForProviderForStatus_result()
5294 
    try:
5295 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5296 
    except TransactionServiceException, ex:
5297 
      result.ex = ex
5298 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
4386 anupam.sin 5302 
 
4600 varun.gupt 5303 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5304 
    args = getBilledOrdersForVendor_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = getBilledOrdersForVendor_result()
5308 
    try:
5309 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
5312 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
4506 phani.kuma 5316 
 
4600 varun.gupt 5317 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5318 
    args = saveBluedartSettlements_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = saveBluedartSettlements_result()
5322 
    try:
5323 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
5326 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
5330 
 
5331 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5332 
    args = savePaymentSettlements_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = savePaymentSettlements_result()
5336 
    try:
5337 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
5340 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
5345 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5346 
    args = saveEBSSettlementSummary_args()
5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
5349 
    result = saveEBSSettlementSummary_result()
5350 
    try:
5351 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5352 
    except TransactionServiceException, ex:
5353 
      result.ex = ex
5354 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
5358 
 
5359 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5360 
    args = getSettlementForPaymentId_args()
5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
5363 
    result = getSettlementForPaymentId_result()
5364 
    try:
5365 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
5368 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
5373 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5374 
    args = getEBSSettlementSummaries_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = getEBSSettlementSummaries_result()
5378 
    try:
5379 
      result.success = self._handler.getEBSSettlementSummaries()
5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
5382 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
5387 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5388 
    args = markEBSSettlementUploaded_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = markEBSSettlementUploaded_result()
5392 
    try:
5393 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5394 
    except TransactionServiceException, ex:
5395 
      result.ex = ex
5396 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
5400 
 
5401 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5402 
    args = getEBSSettlementDate_args()
5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
5405 
    result = getEBSSettlementDate_result()
5406 
    try:
5407 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5408 
    except TransactionServiceException, ex:
5409 
      result.ex = ex
5410 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
5414 
 
5415 
 
94 ashish 5416 
# HELPER FUNCTIONS AND STRUCTURES
5417 
 
5418 
class createTransaction_args:
5419 
  """
5420 
  Attributes:
5421 
   - transaction
5422 
  """
5423 
 
5424 
  thrift_spec = (
5425 
    None, # 0
5426 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5427 
  )
5428 
 
5429 
  def __init__(self, transaction=None,):
5430 
    self.transaction = transaction
5431 
 
5432 
  def read(self, iprot):
5433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5435 
      return
5436 
    iprot.readStructBegin()
5437 
    while True:
5438 
      (fname, ftype, fid) = iprot.readFieldBegin()
5439 
      if ftype == TType.STOP:
5440 
        break
5441 
      if fid == 1:
5442 
        if ftype == TType.STRUCT:
5443 
          self.transaction = Transaction()
5444 
          self.transaction.read(iprot)
5445 
        else:
5446 
          iprot.skip(ftype)
5447 
      else:
5448 
        iprot.skip(ftype)
5449 
      iprot.readFieldEnd()
5450 
    iprot.readStructEnd()
5451 
 
5452 
  def write(self, oprot):
5453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5455 
      return
5456 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5457 
    if self.transaction is not None:
94 ashish 5458 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5459 
      self.transaction.write(oprot)
5460 
      oprot.writeFieldEnd()
5461 
    oprot.writeFieldStop()
5462 
    oprot.writeStructEnd()
5463 
 
3431 rajveer 5464 
  def validate(self):
5465 
    return
5466 
 
5467 
 
94 ashish 5468 
  def __repr__(self):
5469 
    L = ['%s=%r' % (key, value)
5470 
      for key, value in self.__dict__.iteritems()]
5471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5472 
 
5473 
  def __eq__(self, other):
5474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5475 
 
5476 
  def __ne__(self, other):
5477 
    return not (self == other)
5478 
 
5479 
class createTransaction_result:
5480 
  """
5481 
  Attributes:
132 ashish 5482 
   - success
94 ashish 5483 
   - ex
5484 
  """
5485 
 
5486 
  thrift_spec = (
132 ashish 5487 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5489 
  )
5490 
 
132 ashish 5491 
  def __init__(self, success=None, ex=None,):
5492 
    self.success = success
94 ashish 5493 
    self.ex = ex
5494 
 
5495 
  def read(self, iprot):
5496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5498 
      return
5499 
    iprot.readStructBegin()
5500 
    while True:
5501 
      (fname, ftype, fid) = iprot.readFieldBegin()
5502 
      if ftype == TType.STOP:
5503 
        break
132 ashish 5504 
      if fid == 0:
5505 
        if ftype == TType.I64:
5506 
          self.success = iprot.readI64();
5507 
        else:
5508 
          iprot.skip(ftype)
5509 
      elif fid == 1:
94 ashish 5510 
        if ftype == TType.STRUCT:
5511 
          self.ex = TransactionServiceException()
5512 
          self.ex.read(iprot)
5513 
        else:
5514 
          iprot.skip(ftype)
5515 
      else:
5516 
        iprot.skip(ftype)
5517 
      iprot.readFieldEnd()
5518 
    iprot.readStructEnd()
5519 
 
5520 
  def write(self, oprot):
5521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5523 
      return
5524 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5525 
    if self.success is not None:
132 ashish 5526 
      oprot.writeFieldBegin('success', TType.I64, 0)
5527 
      oprot.writeI64(self.success)
5528 
      oprot.writeFieldEnd()
3431 rajveer 5529 
    if self.ex is not None:
94 ashish 5530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5531 
      self.ex.write(oprot)
5532 
      oprot.writeFieldEnd()
5533 
    oprot.writeFieldStop()
5534 
    oprot.writeStructEnd()
5535 
 
3431 rajveer 5536 
  def validate(self):
5537 
    return
5538 
 
5539 
 
94 ashish 5540 
  def __repr__(self):
5541 
    L = ['%s=%r' % (key, value)
5542 
      for key, value in self.__dict__.iteritems()]
5543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5544 
 
5545 
  def __eq__(self, other):
5546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5547 
 
5548 
  def __ne__(self, other):
5549 
    return not (self == other)
5550 
 
5551 
class getTransaction_args:
5552 
  """
5553 
  Attributes:
5554 
   - id
5555 
  """
5556 
 
5557 
  thrift_spec = (
5558 
    None, # 0
5559 
    (1, TType.I64, 'id', None, None, ), # 1
5560 
  )
5561 
 
5562 
  def __init__(self, id=None,):
5563 
    self.id = id
5564 
 
5565 
  def read(self, iprot):
5566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5568 
      return
5569 
    iprot.readStructBegin()
5570 
    while True:
5571 
      (fname, ftype, fid) = iprot.readFieldBegin()
5572 
      if ftype == TType.STOP:
5573 
        break
5574 
      if fid == 1:
5575 
        if ftype == TType.I64:
5576 
          self.id = iprot.readI64();
5577 
        else:
5578 
          iprot.skip(ftype)
5579 
      else:
5580 
        iprot.skip(ftype)
5581 
      iprot.readFieldEnd()
5582 
    iprot.readStructEnd()
5583 
 
5584 
  def write(self, oprot):
5585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5587 
      return
5588 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5589 
    if self.id is not None:
94 ashish 5590 
      oprot.writeFieldBegin('id', TType.I64, 1)
5591 
      oprot.writeI64(self.id)
5592 
      oprot.writeFieldEnd()
5593 
    oprot.writeFieldStop()
5594 
    oprot.writeStructEnd()
5595 
 
3431 rajveer 5596 
  def validate(self):
5597 
    return
5598 
 
5599 
 
94 ashish 5600 
  def __repr__(self):
5601 
    L = ['%s=%r' % (key, value)
5602 
      for key, value in self.__dict__.iteritems()]
5603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5604 
 
5605 
  def __eq__(self, other):
5606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5607 
 
5608 
  def __ne__(self, other):
5609 
    return not (self == other)
5610 
 
5611 
class getTransaction_result:
5612 
  """
5613 
  Attributes:
5614 
   - success
5615 
   - ex
5616 
  """
5617 
 
5618 
  thrift_spec = (
5619 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5621 
  )
5622 
 
5623 
  def __init__(self, success=None, ex=None,):
5624 
    self.success = success
5625 
    self.ex = ex
5626 
 
5627 
  def read(self, iprot):
5628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5630 
      return
5631 
    iprot.readStructBegin()
5632 
    while True:
5633 
      (fname, ftype, fid) = iprot.readFieldBegin()
5634 
      if ftype == TType.STOP:
5635 
        break
5636 
      if fid == 0:
5637 
        if ftype == TType.STRUCT:
5638 
          self.success = Transaction()
5639 
          self.success.read(iprot)
5640 
        else:
5641 
          iprot.skip(ftype)
5642 
      elif fid == 1:
5643 
        if ftype == TType.STRUCT:
5644 
          self.ex = TransactionServiceException()
5645 
          self.ex.read(iprot)
5646 
        else:
5647 
          iprot.skip(ftype)
5648 
      else:
5649 
        iprot.skip(ftype)
5650 
      iprot.readFieldEnd()
5651 
    iprot.readStructEnd()
5652 
 
5653 
  def write(self, oprot):
5654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5656 
      return
5657 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5658 
    if self.success is not None:
94 ashish 5659 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5660 
      self.success.write(oprot)
5661 
      oprot.writeFieldEnd()
3431 rajveer 5662 
    if self.ex is not None:
94 ashish 5663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5664 
      self.ex.write(oprot)
5665 
      oprot.writeFieldEnd()
5666 
    oprot.writeFieldStop()
5667 
    oprot.writeStructEnd()
5668 
 
3431 rajveer 5669 
  def validate(self):
5670 
    return
5671 
 
5672 
 
94 ashish 5673 
  def __repr__(self):
5674 
    L = ['%s=%r' % (key, value)
5675 
      for key, value in self.__dict__.iteritems()]
5676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5677 
 
5678 
  def __eq__(self, other):
5679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5680 
 
5681 
  def __ne__(self, other):
5682 
    return not (self == other)
5683 
 
5684 
class getTransactionsForCustomer_args:
5685 
  """
5686 
  Attributes:
5687 
   - customerId
5688 
   - from_date
5689 
   - to_date
5690 
   - status
5691 
  """
5692 
 
5693 
  thrift_spec = (
5694 
    None, # 0
5695 
    (1, TType.I64, 'customerId', None, None, ), # 1
5696 
    (2, TType.I64, 'from_date', None, None, ), # 2
5697 
    (3, TType.I64, 'to_date', None, None, ), # 3
5698 
    (4, TType.I32, 'status', None, None, ), # 4
5699 
  )
5700 
 
5701 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5702 
    self.customerId = customerId
5703 
    self.from_date = from_date
5704 
    self.to_date = to_date
5705 
    self.status = status
5706 
 
5707 
  def read(self, iprot):
5708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5710 
      return
5711 
    iprot.readStructBegin()
5712 
    while True:
5713 
      (fname, ftype, fid) = iprot.readFieldBegin()
5714 
      if ftype == TType.STOP:
5715 
        break
5716 
      if fid == 1:
5717 
        if ftype == TType.I64:
5718 
          self.customerId = iprot.readI64();
5719 
        else:
5720 
          iprot.skip(ftype)
5721 
      elif fid == 2:
5722 
        if ftype == TType.I64:
5723 
          self.from_date = iprot.readI64();
5724 
        else:
5725 
          iprot.skip(ftype)
5726 
      elif fid == 3:
5727 
        if ftype == TType.I64:
5728 
          self.to_date = iprot.readI64();
5729 
        else:
5730 
          iprot.skip(ftype)
5731 
      elif fid == 4:
5732 
        if ftype == TType.I32:
5733 
          self.status = iprot.readI32();
5734 
        else:
5735 
          iprot.skip(ftype)
5736 
      else:
5737 
        iprot.skip(ftype)
5738 
      iprot.readFieldEnd()
5739 
    iprot.readStructEnd()
5740 
 
5741 
  def write(self, oprot):
5742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5744 
      return
5745 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5746 
    if self.customerId is not None:
94 ashish 5747 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5748 
      oprot.writeI64(self.customerId)
5749 
      oprot.writeFieldEnd()
3431 rajveer 5750 
    if self.from_date is not None:
94 ashish 5751 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5752 
      oprot.writeI64(self.from_date)
5753 
      oprot.writeFieldEnd()
3431 rajveer 5754 
    if self.to_date is not None:
94 ashish 5755 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5756 
      oprot.writeI64(self.to_date)
5757 
      oprot.writeFieldEnd()
3431 rajveer 5758 
    if self.status is not None:
94 ashish 5759 
      oprot.writeFieldBegin('status', TType.I32, 4)
5760 
      oprot.writeI32(self.status)
5761 
      oprot.writeFieldEnd()
5762 
    oprot.writeFieldStop()
5763 
    oprot.writeStructEnd()
5764 
 
3431 rajveer 5765 
  def validate(self):
5766 
    return
5767 
 
5768 
 
94 ashish 5769 
  def __repr__(self):
5770 
    L = ['%s=%r' % (key, value)
5771 
      for key, value in self.__dict__.iteritems()]
5772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5773 
 
5774 
  def __eq__(self, other):
5775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5776 
 
5777 
  def __ne__(self, other):
5778 
    return not (self == other)
5779 
 
5780 
class getTransactionsForCustomer_result:
5781 
  """
5782 
  Attributes:
5783 
   - success
5784 
   - ex
5785 
  """
5786 
 
5787 
  thrift_spec = (
5788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5790 
  )
5791 
 
5792 
  def __init__(self, success=None, ex=None,):
5793 
    self.success = success
5794 
    self.ex = ex
5795 
 
5796 
  def read(self, iprot):
5797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5799 
      return
5800 
    iprot.readStructBegin()
5801 
    while True:
5802 
      (fname, ftype, fid) = iprot.readFieldBegin()
5803 
      if ftype == TType.STOP:
5804 
        break
5805 
      if fid == 0:
5806 
        if ftype == TType.LIST:
5807 
          self.success = []
685 chandransh 5808 
          (_etype17, _size14) = iprot.readListBegin()
5809 
          for _i18 in xrange(_size14):
5810 
            _elem19 = Transaction()
5811 
            _elem19.read(iprot)
5812 
            self.success.append(_elem19)
94 ashish 5813 
          iprot.readListEnd()
5814 
        else:
5815 
          iprot.skip(ftype)
5816 
      elif fid == 1:
5817 
        if ftype == TType.STRUCT:
5818 
          self.ex = TransactionServiceException()
5819 
          self.ex.read(iprot)
5820 
        else:
5821 
          iprot.skip(ftype)
5822 
      else:
5823 
        iprot.skip(ftype)
5824 
      iprot.readFieldEnd()
5825 
    iprot.readStructEnd()
5826 
 
5827 
  def write(self, oprot):
5828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5830 
      return
5831 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5832 
    if self.success is not None:
94 ashish 5833 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5834 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5835 
      for iter20 in self.success:
5836 
        iter20.write(oprot)
94 ashish 5837 
      oprot.writeListEnd()
5838 
      oprot.writeFieldEnd()
3431 rajveer 5839 
    if self.ex is not None:
94 ashish 5840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5841 
      self.ex.write(oprot)
5842 
      oprot.writeFieldEnd()
5843 
    oprot.writeFieldStop()
5844 
    oprot.writeStructEnd()
5845 
 
3431 rajveer 5846 
  def validate(self):
5847 
    return
5848 
 
5849 
 
94 ashish 5850 
  def __repr__(self):
5851 
    L = ['%s=%r' % (key, value)
5852 
      for key, value in self.__dict__.iteritems()]
5853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5854 
 
5855 
  def __eq__(self, other):
5856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5857 
 
5858 
  def __ne__(self, other):
5859 
    return not (self == other)
5860 
 
132 ashish 5861 
class getTransactionsForShoppingCartId_args:
5862 
  """
5863 
  Attributes:
5864 
   - shoppingCartId
5865 
  """
5866 
 
5867 
  thrift_spec = (
5868 
    None, # 0
5869 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5870 
  )
5871 
 
5872 
  def __init__(self, shoppingCartId=None,):
5873 
    self.shoppingCartId = shoppingCartId
5874 
 
5875 
  def read(self, iprot):
5876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5878 
      return
5879 
    iprot.readStructBegin()
5880 
    while True:
5881 
      (fname, ftype, fid) = iprot.readFieldBegin()
5882 
      if ftype == TType.STOP:
5883 
        break
5884 
      if fid == 1:
5885 
        if ftype == TType.I64:
5886 
          self.shoppingCartId = iprot.readI64();
5887 
        else:
5888 
          iprot.skip(ftype)
5889 
      else:
5890 
        iprot.skip(ftype)
5891 
      iprot.readFieldEnd()
5892 
    iprot.readStructEnd()
5893 
 
5894 
  def write(self, oprot):
5895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5897 
      return
5898 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5899 
    if self.shoppingCartId is not None:
132 ashish 5900 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5901 
      oprot.writeI64(self.shoppingCartId)
5902 
      oprot.writeFieldEnd()
5903 
    oprot.writeFieldStop()
5904 
    oprot.writeStructEnd()
5905 
 
3431 rajveer 5906 
  def validate(self):
5907 
    return
5908 
 
5909 
 
132 ashish 5910 
  def __repr__(self):
5911 
    L = ['%s=%r' % (key, value)
5912 
      for key, value in self.__dict__.iteritems()]
5913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5914 
 
5915 
  def __eq__(self, other):
5916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5917 
 
5918 
  def __ne__(self, other):
5919 
    return not (self == other)
5920 
 
5921 
class getTransactionsForShoppingCartId_result:
5922 
  """
5923 
  Attributes:
5924 
   - success
5925 
   - ex
5926 
  """
5927 
 
5928 
  thrift_spec = (
5929 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5931 
  )
5932 
 
5933 
  def __init__(self, success=None, ex=None,):
5934 
    self.success = success
5935 
    self.ex = ex
5936 
 
5937 
  def read(self, iprot):
5938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5940 
      return
5941 
    iprot.readStructBegin()
5942 
    while True:
5943 
      (fname, ftype, fid) = iprot.readFieldBegin()
5944 
      if ftype == TType.STOP:
5945 
        break
5946 
      if fid == 0:
5947 
        if ftype == TType.LIST:
5948 
          self.success = []
685 chandransh 5949 
          (_etype24, _size21) = iprot.readListBegin()
5950 
          for _i25 in xrange(_size21):
5951 
            _elem26 = Transaction()
5952 
            _elem26.read(iprot)
5953 
            self.success.append(_elem26)
132 ashish 5954 
          iprot.readListEnd()
5955 
        else:
5956 
          iprot.skip(ftype)
5957 
      elif fid == 1:
5958 
        if ftype == TType.STRUCT:
5959 
          self.ex = TransactionServiceException()
5960 
          self.ex.read(iprot)
5961 
        else:
5962 
          iprot.skip(ftype)
5963 
      else:
5964 
        iprot.skip(ftype)
5965 
      iprot.readFieldEnd()
5966 
    iprot.readStructEnd()
5967 
 
5968 
  def write(self, oprot):
5969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5971 
      return
5972 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5973 
    if self.success is not None:
132 ashish 5974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5976 
      for iter27 in self.success:
5977 
        iter27.write(oprot)
132 ashish 5978 
      oprot.writeListEnd()
5979 
      oprot.writeFieldEnd()
3431 rajveer 5980 
    if self.ex is not None:
132 ashish 5981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5982 
      self.ex.write(oprot)
5983 
      oprot.writeFieldEnd()
5984 
    oprot.writeFieldStop()
5985 
    oprot.writeStructEnd()
5986 
 
3431 rajveer 5987 
  def validate(self):
5988 
    return
5989 
 
5990 
 
132 ashish 5991 
  def __repr__(self):
5992 
    L = ['%s=%r' % (key, value)
5993 
      for key, value in self.__dict__.iteritems()]
5994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5995 
 
5996 
  def __eq__(self, other):
5997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5998 
 
5999 
  def __ne__(self, other):
6000 
    return not (self == other)
6001 
 
94 ashish 6002 
class getTransactionStatus_args:
6003 
  """
6004 
  Attributes:
6005 
   - transactionId
6006 
  """
6007 
 
6008 
  thrift_spec = (
6009 
    None, # 0
6010 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6011 
  )
6012 
 
6013 
  def __init__(self, transactionId=None,):
6014 
    self.transactionId = transactionId
6015 
 
6016 
  def read(self, iprot):
6017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6019 
      return
6020 
    iprot.readStructBegin()
6021 
    while True:
6022 
      (fname, ftype, fid) = iprot.readFieldBegin()
6023 
      if ftype == TType.STOP:
6024 
        break
6025 
      if fid == 1:
6026 
        if ftype == TType.I64:
6027 
          self.transactionId = iprot.readI64();
6028 
        else:
6029 
          iprot.skip(ftype)
6030 
      else:
6031 
        iprot.skip(ftype)
6032 
      iprot.readFieldEnd()
6033 
    iprot.readStructEnd()
6034 
 
6035 
  def write(self, oprot):
6036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6038 
      return
6039 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6040 
    if self.transactionId is not None:
94 ashish 6041 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6042 
      oprot.writeI64(self.transactionId)
6043 
      oprot.writeFieldEnd()
6044 
    oprot.writeFieldStop()
6045 
    oprot.writeStructEnd()
6046 
 
3431 rajveer 6047 
  def validate(self):
6048 
    return
6049 
 
6050 
 
94 ashish 6051 
  def __repr__(self):
6052 
    L = ['%s=%r' % (key, value)
6053 
      for key, value in self.__dict__.iteritems()]
6054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6055 
 
6056 
  def __eq__(self, other):
6057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6058 
 
6059 
  def __ne__(self, other):
6060 
    return not (self == other)
6061 
 
6062 
class getTransactionStatus_result:
6063 
  """
6064 
  Attributes:
6065 
   - success
6066 
   - ex
6067 
  """
6068 
 
6069 
  thrift_spec = (
6070 
    (0, TType.I32, 'success', None, None, ), # 0
6071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6072 
  )
6073 
 
6074 
  def __init__(self, success=None, ex=None,):
6075 
    self.success = success
6076 
    self.ex = ex
6077 
 
6078 
  def read(self, iprot):
6079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6081 
      return
6082 
    iprot.readStructBegin()
6083 
    while True:
6084 
      (fname, ftype, fid) = iprot.readFieldBegin()
6085 
      if ftype == TType.STOP:
6086 
        break
6087 
      if fid == 0:
6088 
        if ftype == TType.I32:
6089 
          self.success = iprot.readI32();
6090 
        else:
6091 
          iprot.skip(ftype)
6092 
      elif fid == 1:
6093 
        if ftype == TType.STRUCT:
6094 
          self.ex = TransactionServiceException()
6095 
          self.ex.read(iprot)
6096 
        else:
6097 
          iprot.skip(ftype)
6098 
      else:
6099 
        iprot.skip(ftype)
6100 
      iprot.readFieldEnd()
6101 
    iprot.readStructEnd()
6102 
 
6103 
  def write(self, oprot):
6104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6106 
      return
6107 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6108 
    if self.success is not None:
94 ashish 6109 
      oprot.writeFieldBegin('success', TType.I32, 0)
6110 
      oprot.writeI32(self.success)
6111 
      oprot.writeFieldEnd()
3431 rajveer 6112 
    if self.ex is not None:
94 ashish 6113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6114 
      self.ex.write(oprot)
6115 
      oprot.writeFieldEnd()
6116 
    oprot.writeFieldStop()
6117 
    oprot.writeStructEnd()
6118 
 
3431 rajveer 6119 
  def validate(self):
6120 
    return
6121 
 
6122 
 
94 ashish 6123 
  def __repr__(self):
6124 
    L = ['%s=%r' % (key, value)
6125 
      for key, value in self.__dict__.iteritems()]
6126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6127 
 
6128 
  def __eq__(self, other):
6129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6130 
 
6131 
  def __ne__(self, other):
6132 
    return not (self == other)
6133 
 
6134 
class changeTransactionStatus_args:
6135 
  """
6136 
  Attributes:
6137 
   - transactionId
6138 
   - status
6139 
   - description
6140 
  """
6141 
 
6142 
  thrift_spec = (
6143 
    None, # 0
6144 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6145 
    (2, TType.I32, 'status', None, None, ), # 2
6146 
    (3, TType.STRING, 'description', None, None, ), # 3
6147 
  )
6148 
 
6149 
  def __init__(self, transactionId=None, status=None, description=None,):
6150 
    self.transactionId = transactionId
6151 
    self.status = status
6152 
    self.description = description
6153 
 
6154 
  def read(self, iprot):
6155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6157 
      return
6158 
    iprot.readStructBegin()
6159 
    while True:
6160 
      (fname, ftype, fid) = iprot.readFieldBegin()
6161 
      if ftype == TType.STOP:
6162 
        break
6163 
      if fid == 1:
6164 
        if ftype == TType.I64:
6165 
          self.transactionId = iprot.readI64();
6166 
        else:
6167 
          iprot.skip(ftype)
6168 
      elif fid == 2:
6169 
        if ftype == TType.I32:
6170 
          self.status = iprot.readI32();
6171 
        else:
6172 
          iprot.skip(ftype)
6173 
      elif fid == 3:
6174 
        if ftype == TType.STRING:
6175 
          self.description = iprot.readString();
6176 
        else:
6177 
          iprot.skip(ftype)
6178 
      else:
6179 
        iprot.skip(ftype)
6180 
      iprot.readFieldEnd()
6181 
    iprot.readStructEnd()
6182 
 
6183 
  def write(self, oprot):
6184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6186 
      return
6187 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6188 
    if self.transactionId is not None:
94 ashish 6189 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6190 
      oprot.writeI64(self.transactionId)
6191 
      oprot.writeFieldEnd()
3431 rajveer 6192 
    if self.status is not None:
94 ashish 6193 
      oprot.writeFieldBegin('status', TType.I32, 2)
6194 
      oprot.writeI32(self.status)
6195 
      oprot.writeFieldEnd()
3431 rajveer 6196 
    if self.description is not None:
94 ashish 6197 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6198 
      oprot.writeString(self.description)
6199 
      oprot.writeFieldEnd()
6200 
    oprot.writeFieldStop()
6201 
    oprot.writeStructEnd()
6202 
 
3431 rajveer 6203 
  def validate(self):
6204 
    return
6205 
 
6206 
 
94 ashish 6207 
  def __repr__(self):
6208 
    L = ['%s=%r' % (key, value)
6209 
      for key, value in self.__dict__.iteritems()]
6210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6211 
 
6212 
  def __eq__(self, other):
6213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6214 
 
6215 
  def __ne__(self, other):
6216 
    return not (self == other)
6217 
 
6218 
class changeTransactionStatus_result:
6219 
  """
6220 
  Attributes:
6221 
   - success
6222 
   - ex
6223 
  """
6224 
 
6225 
  thrift_spec = (
6226 
    (0, TType.BOOL, 'success', None, None, ), # 0
6227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6228 
  )
6229 
 
6230 
  def __init__(self, success=None, ex=None,):
6231 
    self.success = success
6232 
    self.ex = ex
6233 
 
6234 
  def read(self, iprot):
6235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6237 
      return
6238 
    iprot.readStructBegin()
6239 
    while True:
6240 
      (fname, ftype, fid) = iprot.readFieldBegin()
6241 
      if ftype == TType.STOP:
6242 
        break
6243 
      if fid == 0:
6244 
        if ftype == TType.BOOL:
6245 
          self.success = iprot.readBool();
6246 
        else:
6247 
          iprot.skip(ftype)
6248 
      elif fid == 1:
6249 
        if ftype == TType.STRUCT:
6250 
          self.ex = TransactionServiceException()
6251 
          self.ex.read(iprot)
6252 
        else:
6253 
          iprot.skip(ftype)
6254 
      else:
6255 
        iprot.skip(ftype)
6256 
      iprot.readFieldEnd()
6257 
    iprot.readStructEnd()
6258 
 
6259 
  def write(self, oprot):
6260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6262 
      return
6263 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6264 
    if self.success is not None:
94 ashish 6265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6266 
      oprot.writeBool(self.success)
6267 
      oprot.writeFieldEnd()
3431 rajveer 6268 
    if self.ex is not None:
94 ashish 6269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6270 
      self.ex.write(oprot)
6271 
      oprot.writeFieldEnd()
6272 
    oprot.writeFieldStop()
6273 
    oprot.writeStructEnd()
6274 
 
3431 rajveer 6275 
  def validate(self):
6276 
    return
6277 
 
6278 
 
94 ashish 6279 
  def __repr__(self):
6280 
    L = ['%s=%r' % (key, value)
6281 
      for key, value in self.__dict__.iteritems()]
6282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6283 
 
6284 
  def __eq__(self, other):
6285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6286 
 
6287 
  def __ne__(self, other):
6288 
    return not (self == other)
6289 
 
1398 varun.gupt 6290 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6291 
  """
6292 
  Attributes:
6293 
   - transactionId
6294 
  """
6295 
 
6296 
  thrift_spec = (
6297 
    None, # 0
6298 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6299 
  )
6300 
 
6301 
  def __init__(self, transactionId=None,):
6302 
    self.transactionId = transactionId
6303 
 
6304 
  def read(self, iprot):
6305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6307 
      return
6308 
    iprot.readStructBegin()
6309 
    while True:
6310 
      (fname, ftype, fid) = iprot.readFieldBegin()
6311 
      if ftype == TType.STOP:
6312 
        break
6313 
      if fid == 1:
6314 
        if ftype == TType.I64:
6315 
          self.transactionId = iprot.readI64();
6316 
        else:
6317 
          iprot.skip(ftype)
6318 
      else:
6319 
        iprot.skip(ftype)
6320 
      iprot.readFieldEnd()
6321 
    iprot.readStructEnd()
6322 
 
6323 
  def write(self, oprot):
6324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6326 
      return
1398 varun.gupt 6327 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6328 
    if self.transactionId is not None:
1382 varun.gupt 6329 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6330 
      oprot.writeI64(self.transactionId)
6331 
      oprot.writeFieldEnd()
6332 
    oprot.writeFieldStop()
6333 
    oprot.writeStructEnd()
6334 
 
3431 rajveer 6335 
  def validate(self):
6336 
    return
6337 
 
6338 
 
1382 varun.gupt 6339 
  def __repr__(self):
6340 
    L = ['%s=%r' % (key, value)
6341 
      for key, value in self.__dict__.iteritems()]
6342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6343 
 
6344 
  def __eq__(self, other):
6345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6346 
 
6347 
  def __ne__(self, other):
6348 
    return not (self == other)
6349 
 
1398 varun.gupt 6350 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6351 
  """
6352 
  Attributes:
6353 
   - success
6354 
   - ex
6355 
  """
6356 
 
6357 
  thrift_spec = (
6358 
    (0, TType.BOOL, 'success', None, None, ), # 0
6359 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6360 
  )
6361 
 
6362 
  def __init__(self, success=None, ex=None,):
6363 
    self.success = success
6364 
    self.ex = ex
6365 
 
6366 
  def read(self, iprot):
6367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6369 
      return
6370 
    iprot.readStructBegin()
6371 
    while True:
6372 
      (fname, ftype, fid) = iprot.readFieldBegin()
6373 
      if ftype == TType.STOP:
6374 
        break
6375 
      if fid == 0:
6376 
        if ftype == TType.BOOL:
6377 
          self.success = iprot.readBool();
6378 
        else:
6379 
          iprot.skip(ftype)
6380 
      elif fid == 1:
6381 
        if ftype == TType.STRUCT:
6382 
          self.ex = TransactionServiceException()
6383 
          self.ex.read(iprot)
6384 
        else:
6385 
          iprot.skip(ftype)
6386 
      else:
6387 
        iprot.skip(ftype)
6388 
      iprot.readFieldEnd()
6389 
    iprot.readStructEnd()
6390 
 
6391 
  def write(self, oprot):
6392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6394 
      return
1398 varun.gupt 6395 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6396 
    if self.success is not None:
1382 varun.gupt 6397 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6398 
      oprot.writeBool(self.success)
6399 
      oprot.writeFieldEnd()
3431 rajveer 6400 
    if self.ex is not None:
1382 varun.gupt 6401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6402 
      self.ex.write(oprot)
6403 
      oprot.writeFieldEnd()
6404 
    oprot.writeFieldStop()
6405 
    oprot.writeStructEnd()
6406 
 
3431 rajveer 6407 
  def validate(self):
6408 
    return
6409 
 
6410 
 
1382 varun.gupt 6411 
  def __repr__(self):
6412 
    L = ['%s=%r' % (key, value)
6413 
      for key, value in self.__dict__.iteritems()]
6414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6415 
 
6416 
  def __eq__(self, other):
6417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6418 
 
6419 
  def __ne__(self, other):
6420 
    return not (self == other)
6421 
 
483 rajveer 6422 
class getAllOrders_args:
94 ashish 6423 
  """
6424 
  Attributes:
483 rajveer 6425 
   - status
6426 
   - from_date
6427 
   - to_date
6428 
   - warehouse_id
94 ashish 6429 
  """
6430 
 
6431 
  thrift_spec = (
6432 
    None, # 0
483 rajveer 6433 
    (1, TType.I32, 'status', None, None, ), # 1
6434 
    (2, TType.I64, 'from_date', None, None, ), # 2
6435 
    (3, TType.I64, 'to_date', None, None, ), # 3
6436 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6437 
  )
6438 
 
483 rajveer 6439 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6440 
    self.status = status
6441 
    self.from_date = from_date
6442 
    self.to_date = to_date
6443 
    self.warehouse_id = warehouse_id
94 ashish 6444 
 
6445 
  def read(self, iprot):
6446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6448 
      return
6449 
    iprot.readStructBegin()
6450 
    while True:
6451 
      (fname, ftype, fid) = iprot.readFieldBegin()
6452 
      if ftype == TType.STOP:
6453 
        break
6454 
      if fid == 1:
483 rajveer 6455 
        if ftype == TType.I32:
6456 
          self.status = iprot.readI32();
94 ashish 6457 
        else:
6458 
          iprot.skip(ftype)
483 rajveer 6459 
      elif fid == 2:
6460 
        if ftype == TType.I64:
6461 
          self.from_date = iprot.readI64();
94 ashish 6462 
        else:
6463 
          iprot.skip(ftype)
483 rajveer 6464 
      elif fid == 3:
6465 
        if ftype == TType.I64:
6466 
          self.to_date = iprot.readI64();
94 ashish 6467 
        else:
6468 
          iprot.skip(ftype)
483 rajveer 6469 
      elif fid == 4:
94 ashish 6470 
        if ftype == TType.I64:
483 rajveer 6471 
          self.warehouse_id = iprot.readI64();
94 ashish 6472 
        else:
6473 
          iprot.skip(ftype)
6474 
      else:
6475 
        iprot.skip(ftype)
6476 
      iprot.readFieldEnd()
6477 
    iprot.readStructEnd()
6478 
 
6479 
  def write(self, oprot):
6480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6482 
      return
483 rajveer 6483 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6484 
    if self.status is not None:
483 rajveer 6485 
      oprot.writeFieldBegin('status', TType.I32, 1)
6486 
      oprot.writeI32(self.status)
94 ashish 6487 
      oprot.writeFieldEnd()
3431 rajveer 6488 
    if self.from_date is not None:
483 rajveer 6489 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6490 
      oprot.writeI64(self.from_date)
94 ashish 6491 
      oprot.writeFieldEnd()
3431 rajveer 6492 
    if self.to_date is not None:
483 rajveer 6493 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6494 
      oprot.writeI64(self.to_date)
94 ashish 6495 
      oprot.writeFieldEnd()
3431 rajveer 6496 
    if self.warehouse_id is not None:
483 rajveer 6497 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6498 
      oprot.writeI64(self.warehouse_id)
94 ashish 6499 
      oprot.writeFieldEnd()
6500 
    oprot.writeFieldStop()
6501 
    oprot.writeStructEnd()
6502 
 
3431 rajveer 6503 
  def validate(self):
6504 
    return
6505 
 
6506 
 
94 ashish 6507 
  def __repr__(self):
6508 
    L = ['%s=%r' % (key, value)
6509 
      for key, value in self.__dict__.iteritems()]
6510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6511 
 
6512 
  def __eq__(self, other):
6513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6514 
 
6515 
  def __ne__(self, other):
6516 
    return not (self == other)
6517 
 
483 rajveer 6518 
class getAllOrders_result:
94 ashish 6519 
  """
6520 
  Attributes:
6521 
   - success
6522 
   - ex
6523 
  """
6524 
 
6525 
  thrift_spec = (
483 rajveer 6526 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6528 
  )
6529 
 
6530 
  def __init__(self, success=None, ex=None,):
6531 
    self.success = success
6532 
    self.ex = ex
6533 
 
6534 
  def read(self, iprot):
6535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6537 
      return
6538 
    iprot.readStructBegin()
6539 
    while True:
6540 
      (fname, ftype, fid) = iprot.readFieldBegin()
6541 
      if ftype == TType.STOP:
6542 
        break
6543 
      if fid == 0:
483 rajveer 6544 
        if ftype == TType.LIST:
6545 
          self.success = []
685 chandransh 6546 
          (_etype31, _size28) = iprot.readListBegin()
6547 
          for _i32 in xrange(_size28):
6548 
            _elem33 = Order()
6549 
            _elem33.read(iprot)
6550 
            self.success.append(_elem33)
483 rajveer 6551 
          iprot.readListEnd()
94 ashish 6552 
        else:
6553 
          iprot.skip(ftype)
6554 
      elif fid == 1:
6555 
        if ftype == TType.STRUCT:
6556 
          self.ex = TransactionServiceException()
6557 
          self.ex.read(iprot)
6558 
        else:
6559 
          iprot.skip(ftype)
6560 
      else:
6561 
        iprot.skip(ftype)
6562 
      iprot.readFieldEnd()
6563 
    iprot.readStructEnd()
6564 
 
6565 
  def write(self, oprot):
6566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6568 
      return
483 rajveer 6569 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6570 
    if self.success is not None:
483 rajveer 6571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6573 
      for iter34 in self.success:
6574 
        iter34.write(oprot)
483 rajveer 6575 
      oprot.writeListEnd()
94 ashish 6576 
      oprot.writeFieldEnd()
3431 rajveer 6577 
    if self.ex is not None:
94 ashish 6578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6579 
      self.ex.write(oprot)
6580 
      oprot.writeFieldEnd()
6581 
    oprot.writeFieldStop()
6582 
    oprot.writeStructEnd()
6583 
 
3431 rajveer 6584 
  def validate(self):
6585 
    return
6586 
 
6587 
 
94 ashish 6588 
  def __repr__(self):
6589 
    L = ['%s=%r' % (key, value)
6590 
      for key, value in self.__dict__.iteritems()]
6591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6592 
 
6593 
  def __eq__(self, other):
6594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6595 
 
6596 
  def __ne__(self, other):
6597 
    return not (self == other)
6598 
 
4133 chandransh 6599 
class getOrdersInBatch_args:
6600 
  """
6601 
  Attributes:
6602 
   - statuses
6603 
   - offset
6604 
   - limit
6605 
   - warehouse_id
6606 
  """
6607 
 
6608 
  thrift_spec = (
6609 
    None, # 0
6610 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6611 
    (2, TType.I64, 'offset', None, None, ), # 2
6612 
    (3, TType.I64, 'limit', None, None, ), # 3
6613 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6614 
  )
6615 
 
6616 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6617 
    self.statuses = statuses
6618 
    self.offset = offset
6619 
    self.limit = limit
6620 
    self.warehouse_id = warehouse_id
6621 
 
6622 
  def read(self, iprot):
6623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6625 
      return
6626 
    iprot.readStructBegin()
6627 
    while True:
6628 
      (fname, ftype, fid) = iprot.readFieldBegin()
6629 
      if ftype == TType.STOP:
6630 
        break
6631 
      if fid == 1:
6632 
        if ftype == TType.LIST:
6633 
          self.statuses = []
6634 
          (_etype38, _size35) = iprot.readListBegin()
6635 
          for _i39 in xrange(_size35):
6636 
            _elem40 = iprot.readI32();
6637 
            self.statuses.append(_elem40)
6638 
          iprot.readListEnd()
6639 
        else:
6640 
          iprot.skip(ftype)
6641 
      elif fid == 2:
6642 
        if ftype == TType.I64:
6643 
          self.offset = iprot.readI64();
6644 
        else:
6645 
          iprot.skip(ftype)
6646 
      elif fid == 3:
6647 
        if ftype == TType.I64:
6648 
          self.limit = iprot.readI64();
6649 
        else:
6650 
          iprot.skip(ftype)
6651 
      elif fid == 4:
6652 
        if ftype == TType.I64:
6653 
          self.warehouse_id = iprot.readI64();
6654 
        else:
6655 
          iprot.skip(ftype)
6656 
      else:
6657 
        iprot.skip(ftype)
6658 
      iprot.readFieldEnd()
6659 
    iprot.readStructEnd()
6660 
 
6661 
  def write(self, oprot):
6662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6664 
      return
6665 
    oprot.writeStructBegin('getOrdersInBatch_args')
6666 
    if self.statuses is not None:
6667 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6668 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6669 
      for iter41 in self.statuses:
6670 
        oprot.writeI32(iter41)
6671 
      oprot.writeListEnd()
6672 
      oprot.writeFieldEnd()
6673 
    if self.offset is not None:
6674 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6675 
      oprot.writeI64(self.offset)
6676 
      oprot.writeFieldEnd()
6677 
    if self.limit is not None:
6678 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6679 
      oprot.writeI64(self.limit)
6680 
      oprot.writeFieldEnd()
6681 
    if self.warehouse_id is not None:
6682 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6683 
      oprot.writeI64(self.warehouse_id)
6684 
      oprot.writeFieldEnd()
6685 
    oprot.writeFieldStop()
6686 
    oprot.writeStructEnd()
6687 
 
6688 
  def validate(self):
6689 
    return
6690 
 
6691 
 
6692 
  def __repr__(self):
6693 
    L = ['%s=%r' % (key, value)
6694 
      for key, value in self.__dict__.iteritems()]
6695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6696 
 
6697 
  def __eq__(self, other):
6698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6699 
 
6700 
  def __ne__(self, other):
6701 
    return not (self == other)
6702 
 
6703 
class getOrdersInBatch_result:
6704 
  """
6705 
  Attributes:
6706 
   - success
6707 
   - ex
6708 
  """
6709 
 
6710 
  thrift_spec = (
6711 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6713 
  )
6714 
 
6715 
  def __init__(self, success=None, ex=None,):
6716 
    self.success = success
6717 
    self.ex = ex
6718 
 
6719 
  def read(self, iprot):
6720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6722 
      return
6723 
    iprot.readStructBegin()
6724 
    while True:
6725 
      (fname, ftype, fid) = iprot.readFieldBegin()
6726 
      if ftype == TType.STOP:
6727 
        break
6728 
      if fid == 0:
6729 
        if ftype == TType.LIST:
6730 
          self.success = []
6731 
          (_etype45, _size42) = iprot.readListBegin()
6732 
          for _i46 in xrange(_size42):
6733 
            _elem47 = Order()
6734 
            _elem47.read(iprot)
6735 
            self.success.append(_elem47)
6736 
          iprot.readListEnd()
6737 
        else:
6738 
          iprot.skip(ftype)
6739 
      elif fid == 1:
6740 
        if ftype == TType.STRUCT:
6741 
          self.ex = TransactionServiceException()
6742 
          self.ex.read(iprot)
6743 
        else:
6744 
          iprot.skip(ftype)
6745 
      else:
6746 
        iprot.skip(ftype)
6747 
      iprot.readFieldEnd()
6748 
    iprot.readStructEnd()
6749 
 
6750 
  def write(self, oprot):
6751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6753 
      return
6754 
    oprot.writeStructBegin('getOrdersInBatch_result')
6755 
    if self.success is not None:
6756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6757 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6758 
      for iter48 in self.success:
6759 
        iter48.write(oprot)
6760 
      oprot.writeListEnd()
6761 
      oprot.writeFieldEnd()
6762 
    if self.ex is not None:
6763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6764 
      self.ex.write(oprot)
6765 
      oprot.writeFieldEnd()
6766 
    oprot.writeFieldStop()
6767 
    oprot.writeStructEnd()
6768 
 
6769 
  def validate(self):
6770 
    return
6771 
 
6772 
 
6773 
  def __repr__(self):
6774 
    L = ['%s=%r' % (key, value)
6775 
      for key, value in self.__dict__.iteritems()]
6776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6777 
 
6778 
  def __eq__(self, other):
6779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6780 
 
6781 
  def __ne__(self, other):
6782 
    return not (self == other)
6783 
 
6784 
class getOrderCount_args:
6785 
  """
6786 
  Attributes:
6787 
   - statuses
6788 
   - warehouseId
6789 
  """
6790 
 
6791 
  thrift_spec = (
6792 
    None, # 0
6793 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6794 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6795 
  )
6796 
 
6797 
  def __init__(self, statuses=None, warehouseId=None,):
6798 
    self.statuses = statuses
6799 
    self.warehouseId = warehouseId
6800 
 
6801 
  def read(self, iprot):
6802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6804 
      return
6805 
    iprot.readStructBegin()
6806 
    while True:
6807 
      (fname, ftype, fid) = iprot.readFieldBegin()
6808 
      if ftype == TType.STOP:
6809 
        break
6810 
      if fid == 1:
6811 
        if ftype == TType.LIST:
6812 
          self.statuses = []
6813 
          (_etype52, _size49) = iprot.readListBegin()
6814 
          for _i53 in xrange(_size49):
6815 
            _elem54 = iprot.readI32();
6816 
            self.statuses.append(_elem54)
6817 
          iprot.readListEnd()
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      elif fid == 2:
6821 
        if ftype == TType.I64:
6822 
          self.warehouseId = iprot.readI64();
6823 
        else:
6824 
          iprot.skip(ftype)
6825 
      else:
6826 
        iprot.skip(ftype)
6827 
      iprot.readFieldEnd()
6828 
    iprot.readStructEnd()
6829 
 
6830 
  def write(self, oprot):
6831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6833 
      return
6834 
    oprot.writeStructBegin('getOrderCount_args')
6835 
    if self.statuses is not None:
6836 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6837 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6838 
      for iter55 in self.statuses:
6839 
        oprot.writeI32(iter55)
6840 
      oprot.writeListEnd()
6841 
      oprot.writeFieldEnd()
6842 
    if self.warehouseId is not None:
6843 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6844 
      oprot.writeI64(self.warehouseId)
6845 
      oprot.writeFieldEnd()
6846 
    oprot.writeFieldStop()
6847 
    oprot.writeStructEnd()
6848 
 
6849 
  def validate(self):
6850 
    return
6851 
 
6852 
 
6853 
  def __repr__(self):
6854 
    L = ['%s=%r' % (key, value)
6855 
      for key, value in self.__dict__.iteritems()]
6856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6857 
 
6858 
  def __eq__(self, other):
6859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6860 
 
6861 
  def __ne__(self, other):
6862 
    return not (self == other)
6863 
 
6864 
class getOrderCount_result:
6865 
  """
6866 
  Attributes:
6867 
   - success
6868 
   - ex
6869 
  """
6870 
 
6871 
  thrift_spec = (
6872 
    (0, TType.I32, 'success', None, None, ), # 0
6873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6874 
  )
6875 
 
6876 
  def __init__(self, success=None, ex=None,):
6877 
    self.success = success
6878 
    self.ex = ex
6879 
 
6880 
  def read(self, iprot):
6881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6883 
      return
6884 
    iprot.readStructBegin()
6885 
    while True:
6886 
      (fname, ftype, fid) = iprot.readFieldBegin()
6887 
      if ftype == TType.STOP:
6888 
        break
6889 
      if fid == 0:
6890 
        if ftype == TType.I32:
6891 
          self.success = iprot.readI32();
6892 
        else:
6893 
          iprot.skip(ftype)
6894 
      elif fid == 1:
6895 
        if ftype == TType.STRUCT:
6896 
          self.ex = TransactionServiceException()
6897 
          self.ex.read(iprot)
6898 
        else:
6899 
          iprot.skip(ftype)
6900 
      else:
6901 
        iprot.skip(ftype)
6902 
      iprot.readFieldEnd()
6903 
    iprot.readStructEnd()
6904 
 
6905 
  def write(self, oprot):
6906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6908 
      return
6909 
    oprot.writeStructBegin('getOrderCount_result')
6910 
    if self.success is not None:
6911 
      oprot.writeFieldBegin('success', TType.I32, 0)
6912 
      oprot.writeI32(self.success)
6913 
      oprot.writeFieldEnd()
6914 
    if self.ex is not None:
6915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6916 
      self.ex.write(oprot)
6917 
      oprot.writeFieldEnd()
6918 
    oprot.writeFieldStop()
6919 
    oprot.writeStructEnd()
6920 
 
6921 
  def validate(self):
6922 
    return
6923 
 
6924 
 
6925 
  def __repr__(self):
6926 
    L = ['%s=%r' % (key, value)
6927 
      for key, value in self.__dict__.iteritems()]
6928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6929 
 
6930 
  def __eq__(self, other):
6931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6932 
 
6933 
  def __ne__(self, other):
6934 
    return not (self == other)
6935 
 
999 varun.gupt 6936 
class getOrdersByBillingDate_args:
6937 
  """
6938 
  Attributes:
6939 
   - status
6940 
   - start_billing_date
6941 
   - end_billing_date
6942 
   - warehouse_id
6943 
  """
6944 
 
6945 
  thrift_spec = (
6946 
    None, # 0
6947 
    (1, TType.I32, 'status', None, None, ), # 1
6948 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6949 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6950 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6951 
  )
6952 
 
6953 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6954 
    self.status = status
6955 
    self.start_billing_date = start_billing_date
6956 
    self.end_billing_date = end_billing_date
6957 
    self.warehouse_id = warehouse_id
6958 
 
6959 
  def read(self, iprot):
6960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6962 
      return
6963 
    iprot.readStructBegin()
6964 
    while True:
6965 
      (fname, ftype, fid) = iprot.readFieldBegin()
6966 
      if ftype == TType.STOP:
6967 
        break
6968 
      if fid == 1:
6969 
        if ftype == TType.I32:
6970 
          self.status = iprot.readI32();
6971 
        else:
6972 
          iprot.skip(ftype)
6973 
      elif fid == 2:
6974 
        if ftype == TType.I64:
6975 
          self.start_billing_date = iprot.readI64();
6976 
        else:
6977 
          iprot.skip(ftype)
6978 
      elif fid == 3:
6979 
        if ftype == TType.I64:
6980 
          self.end_billing_date = iprot.readI64();
6981 
        else:
6982 
          iprot.skip(ftype)
6983 
      elif fid == 4:
6984 
        if ftype == TType.I64:
6985 
          self.warehouse_id = iprot.readI64();
6986 
        else:
6987 
          iprot.skip(ftype)
6988 
      else:
6989 
        iprot.skip(ftype)
6990 
      iprot.readFieldEnd()
6991 
    iprot.readStructEnd()
6992 
 
6993 
  def write(self, oprot):
6994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6996 
      return
6997 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6998 
    if self.status is not None:
999 varun.gupt 6999 
      oprot.writeFieldBegin('status', TType.I32, 1)
7000 
      oprot.writeI32(self.status)
7001 
      oprot.writeFieldEnd()
3431 rajveer 7002 
    if self.start_billing_date is not None:
999 varun.gupt 7003 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7004 
      oprot.writeI64(self.start_billing_date)
7005 
      oprot.writeFieldEnd()
3431 rajveer 7006 
    if self.end_billing_date is not None:
999 varun.gupt 7007 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7008 
      oprot.writeI64(self.end_billing_date)
7009 
      oprot.writeFieldEnd()
3431 rajveer 7010 
    if self.warehouse_id is not None:
999 varun.gupt 7011 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7012 
      oprot.writeI64(self.warehouse_id)
7013 
      oprot.writeFieldEnd()
7014 
    oprot.writeFieldStop()
7015 
    oprot.writeStructEnd()
7016 
 
3431 rajveer 7017 
  def validate(self):
7018 
    return
7019 
 
7020 
 
999 varun.gupt 7021 
  def __repr__(self):
7022 
    L = ['%s=%r' % (key, value)
7023 
      for key, value in self.__dict__.iteritems()]
7024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7025 
 
7026 
  def __eq__(self, other):
7027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7028 
 
7029 
  def __ne__(self, other):
7030 
    return not (self == other)
7031 
 
7032 
class getOrdersByBillingDate_result:
7033 
  """
7034 
  Attributes:
7035 
   - success
7036 
   - ex
7037 
  """
7038 
 
7039 
  thrift_spec = (
7040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7042 
  )
7043 
 
7044 
  def __init__(self, success=None, ex=None,):
7045 
    self.success = success
7046 
    self.ex = ex
7047 
 
7048 
  def read(self, iprot):
7049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7051 
      return
7052 
    iprot.readStructBegin()
7053 
    while True:
7054 
      (fname, ftype, fid) = iprot.readFieldBegin()
7055 
      if ftype == TType.STOP:
7056 
        break
7057 
      if fid == 0:
7058 
        if ftype == TType.LIST:
7059 
          self.success = []
4133 chandransh 7060 
          (_etype59, _size56) = iprot.readListBegin()
7061 
          for _i60 in xrange(_size56):
7062 
            _elem61 = Order()
7063 
            _elem61.read(iprot)
7064 
            self.success.append(_elem61)
999 varun.gupt 7065 
          iprot.readListEnd()
7066 
        else:
7067 
          iprot.skip(ftype)
7068 
      elif fid == 1:
7069 
        if ftype == TType.STRUCT:
7070 
          self.ex = TransactionServiceException()
7071 
          self.ex.read(iprot)
7072 
        else:
7073 
          iprot.skip(ftype)
7074 
      else:
7075 
        iprot.skip(ftype)
7076 
      iprot.readFieldEnd()
7077 
    iprot.readStructEnd()
7078 
 
7079 
  def write(self, oprot):
7080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7082 
      return
7083 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7084 
    if self.success is not None:
999 varun.gupt 7085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7087 
      for iter62 in self.success:
7088 
        iter62.write(oprot)
999 varun.gupt 7089 
      oprot.writeListEnd()
7090 
      oprot.writeFieldEnd()
3431 rajveer 7091 
    if self.ex is not None:
999 varun.gupt 7092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7093 
      self.ex.write(oprot)
7094 
      oprot.writeFieldEnd()
7095 
    oprot.writeFieldStop()
7096 
    oprot.writeStructEnd()
7097 
 
3431 rajveer 7098 
  def validate(self):
7099 
    return
7100 
 
7101 
 
999 varun.gupt 7102 
  def __repr__(self):
7103 
    L = ['%s=%r' % (key, value)
7104 
      for key, value in self.__dict__.iteritems()]
7105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7106 
 
7107 
  def __eq__(self, other):
7108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7109 
 
7110 
  def __ne__(self, other):
7111 
    return not (self == other)
7112 
 
3427 chandransh 7113 
class getOrdersByShippingDate_args:
7114 
  """
7115 
  Attributes:
7116 
   - fromShippingDate
7117 
   - toShippingDate
7118 
   - providerId
7119 
   - warehouseId
3451 chandransh 7120 
   - cod
3427 chandransh 7121 
  """
7122 
 
7123 
  thrift_spec = (
7124 
    None, # 0
7125 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7126 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7127 
    (3, TType.I64, 'providerId', None, None, ), # 3
7128 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7129 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7130 
  )
7131 
 
3451 chandransh 7132 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7133 
    self.fromShippingDate = fromShippingDate
7134 
    self.toShippingDate = toShippingDate
7135 
    self.providerId = providerId
7136 
    self.warehouseId = warehouseId
3451 chandransh 7137 
    self.cod = cod
3427 chandransh 7138 
 
7139 
  def read(self, iprot):
7140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7142 
      return
7143 
    iprot.readStructBegin()
7144 
    while True:
7145 
      (fname, ftype, fid) = iprot.readFieldBegin()
7146 
      if ftype == TType.STOP:
7147 
        break
7148 
      if fid == 1:
7149 
        if ftype == TType.I64:
7150 
          self.fromShippingDate = iprot.readI64();
7151 
        else:
7152 
          iprot.skip(ftype)
7153 
      elif fid == 2:
7154 
        if ftype == TType.I64:
7155 
          self.toShippingDate = iprot.readI64();
7156 
        else:
7157 
          iprot.skip(ftype)
7158 
      elif fid == 3:
7159 
        if ftype == TType.I64:
7160 
          self.providerId = iprot.readI64();
7161 
        else:
7162 
          iprot.skip(ftype)
7163 
      elif fid == 4:
7164 
        if ftype == TType.I64:
7165 
          self.warehouseId = iprot.readI64();
7166 
        else:
7167 
          iprot.skip(ftype)
3451 chandransh 7168 
      elif fid == 5:
7169 
        if ftype == TType.BOOL:
7170 
          self.cod = iprot.readBool();
7171 
        else:
7172 
          iprot.skip(ftype)
3427 chandransh 7173 
      else:
7174 
        iprot.skip(ftype)
7175 
      iprot.readFieldEnd()
7176 
    iprot.readStructEnd()
7177 
 
7178 
  def write(self, oprot):
7179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7181 
      return
7182 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7183 
    if self.fromShippingDate is not None:
3427 chandransh 7184 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7185 
      oprot.writeI64(self.fromShippingDate)
7186 
      oprot.writeFieldEnd()
3431 rajveer 7187 
    if self.toShippingDate is not None:
3427 chandransh 7188 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7189 
      oprot.writeI64(self.toShippingDate)
7190 
      oprot.writeFieldEnd()
3431 rajveer 7191 
    if self.providerId is not None:
3427 chandransh 7192 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7193 
      oprot.writeI64(self.providerId)
7194 
      oprot.writeFieldEnd()
3431 rajveer 7195 
    if self.warehouseId is not None:
3427 chandransh 7196 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7197 
      oprot.writeI64(self.warehouseId)
7198 
      oprot.writeFieldEnd()
3451 chandransh 7199 
    if self.cod is not None:
7200 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7201 
      oprot.writeBool(self.cod)
7202 
      oprot.writeFieldEnd()
3427 chandransh 7203 
    oprot.writeFieldStop()
7204 
    oprot.writeStructEnd()
7205 
 
3431 rajveer 7206 
  def validate(self):
7207 
    return
7208 
 
7209 
 
3427 chandransh 7210 
  def __repr__(self):
7211 
    L = ['%s=%r' % (key, value)
7212 
      for key, value in self.__dict__.iteritems()]
7213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7214 
 
7215 
  def __eq__(self, other):
7216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7217 
 
7218 
  def __ne__(self, other):
7219 
    return not (self == other)
7220 
 
7221 
class getOrdersByShippingDate_result:
7222 
  """
7223 
  Attributes:
7224 
   - success
7225 
   - ex
7226 
  """
7227 
 
7228 
  thrift_spec = (
7229 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7231 
  )
7232 
 
7233 
  def __init__(self, success=None, ex=None,):
7234 
    self.success = success
7235 
    self.ex = ex
7236 
 
7237 
  def read(self, iprot):
7238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7240 
      return
7241 
    iprot.readStructBegin()
7242 
    while True:
7243 
      (fname, ftype, fid) = iprot.readFieldBegin()
7244 
      if ftype == TType.STOP:
7245 
        break
7246 
      if fid == 0:
7247 
        if ftype == TType.LIST:
7248 
          self.success = []
4133 chandransh 7249 
          (_etype66, _size63) = iprot.readListBegin()
7250 
          for _i67 in xrange(_size63):
7251 
            _elem68 = Order()
7252 
            _elem68.read(iprot)
7253 
            self.success.append(_elem68)
3427 chandransh 7254 
          iprot.readListEnd()
7255 
        else:
7256 
          iprot.skip(ftype)
7257 
      elif fid == 1:
7258 
        if ftype == TType.STRUCT:
7259 
          self.ex = TransactionServiceException()
7260 
          self.ex.read(iprot)
7261 
        else:
7262 
          iprot.skip(ftype)
7263 
      else:
7264 
        iprot.skip(ftype)
7265 
      iprot.readFieldEnd()
7266 
    iprot.readStructEnd()
7267 
 
7268 
  def write(self, oprot):
7269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7271 
      return
7272 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7273 
    if self.success is not None:
3427 chandransh 7274 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7275 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7276 
      for iter69 in self.success:
7277 
        iter69.write(oprot)
3427 chandransh 7278 
      oprot.writeListEnd()
7279 
      oprot.writeFieldEnd()
3431 rajveer 7280 
    if self.ex is not None:
3427 chandransh 7281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7282 
      self.ex.write(oprot)
7283 
      oprot.writeFieldEnd()
7284 
    oprot.writeFieldStop()
7285 
    oprot.writeStructEnd()
7286 
 
3431 rajveer 7287 
  def validate(self):
7288 
    return
7289 
 
7290 
 
3427 chandransh 7291 
  def __repr__(self):
7292 
    L = ['%s=%r' % (key, value)
7293 
      for key, value in self.__dict__.iteritems()]
7294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7295 
 
7296 
  def __eq__(self, other):
7297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7298 
 
7299 
  def __ne__(self, other):
7300 
    return not (self == other)
7301 
 
1382 varun.gupt 7302 
class getReturnableOrdersForCustomer_args:
7303 
  """
7304 
  Attributes:
7305 
   - customer_id
7306 
   - limit
7307 
  """
7308 
 
7309 
  thrift_spec = (
7310 
    None, # 0
7311 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7312 
    (2, TType.I64, 'limit', None, None, ), # 2
7313 
  )
7314 
 
7315 
  def __init__(self, customer_id=None, limit=None,):
7316 
    self.customer_id = customer_id
7317 
    self.limit = limit
7318 
 
7319 
  def read(self, iprot):
7320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7322 
      return
7323 
    iprot.readStructBegin()
7324 
    while True:
7325 
      (fname, ftype, fid) = iprot.readFieldBegin()
7326 
      if ftype == TType.STOP:
7327 
        break
7328 
      if fid == 1:
7329 
        if ftype == TType.I64:
7330 
          self.customer_id = iprot.readI64();
7331 
        else:
7332 
          iprot.skip(ftype)
7333 
      elif fid == 2:
7334 
        if ftype == TType.I64:
7335 
          self.limit = iprot.readI64();
7336 
        else:
7337 
          iprot.skip(ftype)
7338 
      else:
7339 
        iprot.skip(ftype)
7340 
      iprot.readFieldEnd()
7341 
    iprot.readStructEnd()
7342 
 
7343 
  def write(self, oprot):
7344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7346 
      return
7347 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7348 
    if self.customer_id is not None:
1382 varun.gupt 7349 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7350 
      oprot.writeI64(self.customer_id)
7351 
      oprot.writeFieldEnd()
3431 rajveer 7352 
    if self.limit is not None:
1382 varun.gupt 7353 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7354 
      oprot.writeI64(self.limit)
7355 
      oprot.writeFieldEnd()
7356 
    oprot.writeFieldStop()
7357 
    oprot.writeStructEnd()
7358 
 
3431 rajveer 7359 
  def validate(self):
7360 
    return
7361 
 
7362 
 
1382 varun.gupt 7363 
  def __repr__(self):
7364 
    L = ['%s=%r' % (key, value)
7365 
      for key, value in self.__dict__.iteritems()]
7366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7367 
 
7368 
  def __eq__(self, other):
7369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7370 
 
7371 
  def __ne__(self, other):
7372 
    return not (self == other)
7373 
 
7374 
class getReturnableOrdersForCustomer_result:
7375 
  """
7376 
  Attributes:
7377 
   - success
7378 
   - ex
7379 
  """
7380 
 
7381 
  thrift_spec = (
7382 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7384 
  )
7385 
 
7386 
  def __init__(self, success=None, ex=None,):
7387 
    self.success = success
7388 
    self.ex = ex
7389 
 
7390 
  def read(self, iprot):
7391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7393 
      return
7394 
    iprot.readStructBegin()
7395 
    while True:
7396 
      (fname, ftype, fid) = iprot.readFieldBegin()
7397 
      if ftype == TType.STOP:
7398 
        break
7399 
      if fid == 0:
7400 
        if ftype == TType.LIST:
7401 
          self.success = []
4133 chandransh 7402 
          (_etype73, _size70) = iprot.readListBegin()
7403 
          for _i74 in xrange(_size70):
7404 
            _elem75 = iprot.readI64();
7405 
            self.success.append(_elem75)
1382 varun.gupt 7406 
          iprot.readListEnd()
7407 
        else:
7408 
          iprot.skip(ftype)
7409 
      elif fid == 1:
7410 
        if ftype == TType.STRUCT:
7411 
          self.ex = TransactionServiceException()
7412 
          self.ex.read(iprot)
7413 
        else:
7414 
          iprot.skip(ftype)
7415 
      else:
7416 
        iprot.skip(ftype)
7417 
      iprot.readFieldEnd()
7418 
    iprot.readStructEnd()
7419 
 
7420 
  def write(self, oprot):
7421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7423 
      return
7424 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7425 
    if self.success is not None:
1382 varun.gupt 7426 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7427 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7428 
      for iter76 in self.success:
7429 
        oprot.writeI64(iter76)
1382 varun.gupt 7430 
      oprot.writeListEnd()
7431 
      oprot.writeFieldEnd()
3431 rajveer 7432 
    if self.ex is not None:
1382 varun.gupt 7433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7434 
      self.ex.write(oprot)
7435 
      oprot.writeFieldEnd()
7436 
    oprot.writeFieldStop()
7437 
    oprot.writeStructEnd()
7438 
 
3431 rajveer 7439 
  def validate(self):
7440 
    return
7441 
 
7442 
 
1382 varun.gupt 7443 
  def __repr__(self):
7444 
    L = ['%s=%r' % (key, value)
7445 
      for key, value in self.__dict__.iteritems()]
7446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7447 
 
7448 
  def __eq__(self, other):
7449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7450 
 
7451 
  def __ne__(self, other):
7452 
    return not (self == other)
7453 
 
7454 
class getCancellableOrdersForCustomer_args:
7455 
  """
7456 
  Attributes:
7457 
   - customer_id
7458 
   - limit
7459 
  """
7460 
 
7461 
  thrift_spec = (
7462 
    None, # 0
7463 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7464 
    (2, TType.I64, 'limit', None, None, ), # 2
7465 
  )
7466 
 
7467 
  def __init__(self, customer_id=None, limit=None,):
7468 
    self.customer_id = customer_id
7469 
    self.limit = limit
7470 
 
7471 
  def read(self, iprot):
7472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7474 
      return
7475 
    iprot.readStructBegin()
7476 
    while True:
7477 
      (fname, ftype, fid) = iprot.readFieldBegin()
7478 
      if ftype == TType.STOP:
7479 
        break
7480 
      if fid == 1:
7481 
        if ftype == TType.I64:
7482 
          self.customer_id = iprot.readI64();
7483 
        else:
7484 
          iprot.skip(ftype)
7485 
      elif fid == 2:
7486 
        if ftype == TType.I64:
7487 
          self.limit = iprot.readI64();
7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      else:
7491 
        iprot.skip(ftype)
7492 
      iprot.readFieldEnd()
7493 
    iprot.readStructEnd()
7494 
 
7495 
  def write(self, oprot):
7496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7498 
      return
7499 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7500 
    if self.customer_id is not None:
1382 varun.gupt 7501 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7502 
      oprot.writeI64(self.customer_id)
7503 
      oprot.writeFieldEnd()
3431 rajveer 7504 
    if self.limit is not None:
1382 varun.gupt 7505 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7506 
      oprot.writeI64(self.limit)
7507 
      oprot.writeFieldEnd()
7508 
    oprot.writeFieldStop()
7509 
    oprot.writeStructEnd()
7510 
 
3431 rajveer 7511 
  def validate(self):
7512 
    return
7513 
 
7514 
 
1382 varun.gupt 7515 
  def __repr__(self):
7516 
    L = ['%s=%r' % (key, value)
7517 
      for key, value in self.__dict__.iteritems()]
7518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7519 
 
7520 
  def __eq__(self, other):
7521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7522 
 
7523 
  def __ne__(self, other):
7524 
    return not (self == other)
7525 
 
7526 
class getCancellableOrdersForCustomer_result:
7527 
  """
7528 
  Attributes:
7529 
   - success
7530 
   - ex
7531 
  """
7532 
 
7533 
  thrift_spec = (
7534 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7536 
  )
7537 
 
7538 
  def __init__(self, success=None, ex=None,):
7539 
    self.success = success
7540 
    self.ex = ex
7541 
 
7542 
  def read(self, iprot):
7543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7545 
      return
7546 
    iprot.readStructBegin()
7547 
    while True:
7548 
      (fname, ftype, fid) = iprot.readFieldBegin()
7549 
      if ftype == TType.STOP:
7550 
        break
7551 
      if fid == 0:
7552 
        if ftype == TType.LIST:
7553 
          self.success = []
4133 chandransh 7554 
          (_etype80, _size77) = iprot.readListBegin()
7555 
          for _i81 in xrange(_size77):
7556 
            _elem82 = iprot.readI64();
7557 
            self.success.append(_elem82)
1382 varun.gupt 7558 
          iprot.readListEnd()
7559 
        else:
7560 
          iprot.skip(ftype)
7561 
      elif fid == 1:
7562 
        if ftype == TType.STRUCT:
7563 
          self.ex = TransactionServiceException()
7564 
          self.ex.read(iprot)
7565 
        else:
7566 
          iprot.skip(ftype)
7567 
      else:
7568 
        iprot.skip(ftype)
7569 
      iprot.readFieldEnd()
7570 
    iprot.readStructEnd()
7571 
 
7572 
  def write(self, oprot):
7573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7575 
      return
7576 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7577 
    if self.success is not None:
1382 varun.gupt 7578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7579 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7580 
      for iter83 in self.success:
7581 
        oprot.writeI64(iter83)
1382 varun.gupt 7582 
      oprot.writeListEnd()
7583 
      oprot.writeFieldEnd()
3431 rajveer 7584 
    if self.ex is not None:
1382 varun.gupt 7585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7586 
      self.ex.write(oprot)
7587 
      oprot.writeFieldEnd()
7588 
    oprot.writeFieldStop()
7589 
    oprot.writeStructEnd()
7590 
 
3431 rajveer 7591 
  def validate(self):
7592 
    return
7593 
 
7594 
 
1382 varun.gupt 7595 
  def __repr__(self):
7596 
    L = ['%s=%r' % (key, value)
7597 
      for key, value in self.__dict__.iteritems()]
7598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7599 
 
7600 
  def __eq__(self, other):
7601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7602 
 
7603 
  def __ne__(self, other):
7604 
    return not (self == other)
7605 
 
483 rajveer 7606 
class changeOrderStatus_args:
94 ashish 7607 
  """
7608 
  Attributes:
483 rajveer 7609 
   - orderId
7610 
   - status
7611 
   - description
94 ashish 7612 
  """
7613 
 
7614 
  thrift_spec = (
7615 
    None, # 0
483 rajveer 7616 
    (1, TType.I64, 'orderId', None, None, ), # 1
7617 
    (2, TType.I32, 'status', None, None, ), # 2
7618 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7619 
  )
7620 
 
483 rajveer 7621 
  def __init__(self, orderId=None, status=None, description=None,):
7622 
    self.orderId = orderId
7623 
    self.status = status
7624 
    self.description = description
94 ashish 7625 
 
7626 
  def read(self, iprot):
7627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7629 
      return
7630 
    iprot.readStructBegin()
7631 
    while True:
7632 
      (fname, ftype, fid) = iprot.readFieldBegin()
7633 
      if ftype == TType.STOP:
7634 
        break
7635 
      if fid == 1:
7636 
        if ftype == TType.I64:
483 rajveer 7637 
          self.orderId = iprot.readI64();
94 ashish 7638 
        else:
7639 
          iprot.skip(ftype)
7640 
      elif fid == 2:
483 rajveer 7641 
        if ftype == TType.I32:
7642 
          self.status = iprot.readI32();
94 ashish 7643 
        else:
7644 
          iprot.skip(ftype)
483 rajveer 7645 
      elif fid == 3:
7646 
        if ftype == TType.STRING:
7647 
          self.description = iprot.readString();
7648 
        else:
7649 
          iprot.skip(ftype)
94 ashish 7650 
      else:
7651 
        iprot.skip(ftype)
7652 
      iprot.readFieldEnd()
7653 
    iprot.readStructEnd()
7654 
 
7655 
  def write(self, oprot):
7656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7658 
      return
483 rajveer 7659 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7660 
    if self.orderId is not None:
483 rajveer 7661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7662 
      oprot.writeI64(self.orderId)
94 ashish 7663 
      oprot.writeFieldEnd()
3431 rajveer 7664 
    if self.status is not None:
483 rajveer 7665 
      oprot.writeFieldBegin('status', TType.I32, 2)
7666 
      oprot.writeI32(self.status)
94 ashish 7667 
      oprot.writeFieldEnd()
3431 rajveer 7668 
    if self.description is not None:
483 rajveer 7669 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7670 
      oprot.writeString(self.description)
7671 
      oprot.writeFieldEnd()
94 ashish 7672 
    oprot.writeFieldStop()
7673 
    oprot.writeStructEnd()
7674 
 
3431 rajveer 7675 
  def validate(self):
7676 
    return
7677 
 
7678 
 
94 ashish 7679 
  def __repr__(self):
7680 
    L = ['%s=%r' % (key, value)
7681 
      for key, value in self.__dict__.iteritems()]
7682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7683 
 
7684 
  def __eq__(self, other):
7685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7686 
 
7687 
  def __ne__(self, other):
7688 
    return not (self == other)
7689 
 
483 rajveer 7690 
class changeOrderStatus_result:
94 ashish 7691 
  """
7692 
  Attributes:
7693 
   - success
7694 
   - ex
7695 
  """
7696 
 
7697 
  thrift_spec = (
7698 
    (0, TType.BOOL, 'success', None, None, ), # 0
7699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7700 
  )
7701 
 
7702 
  def __init__(self, success=None, ex=None,):
7703 
    self.success = success
7704 
    self.ex = ex
7705 
 
7706 
  def read(self, iprot):
7707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7709 
      return
7710 
    iprot.readStructBegin()
7711 
    while True:
7712 
      (fname, ftype, fid) = iprot.readFieldBegin()
7713 
      if ftype == TType.STOP:
7714 
        break
7715 
      if fid == 0:
7716 
        if ftype == TType.BOOL:
7717 
          self.success = iprot.readBool();
7718 
        else:
7719 
          iprot.skip(ftype)
7720 
      elif fid == 1:
7721 
        if ftype == TType.STRUCT:
7722 
          self.ex = TransactionServiceException()
7723 
          self.ex.read(iprot)
7724 
        else:
7725 
          iprot.skip(ftype)
7726 
      else:
7727 
        iprot.skip(ftype)
7728 
      iprot.readFieldEnd()
7729 
    iprot.readStructEnd()
7730 
 
7731 
  def write(self, oprot):
7732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7734 
      return
483 rajveer 7735 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7736 
    if self.success is not None:
94 ashish 7737 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7738 
      oprot.writeBool(self.success)
7739 
      oprot.writeFieldEnd()
3431 rajveer 7740 
    if self.ex is not None:
94 ashish 7741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7742 
      self.ex.write(oprot)
7743 
      oprot.writeFieldEnd()
7744 
    oprot.writeFieldStop()
7745 
    oprot.writeStructEnd()
7746 
 
3431 rajveer 7747 
  def validate(self):
7748 
    return
7749 
 
7750 
 
94 ashish 7751 
  def __repr__(self):
7752 
    L = ['%s=%r' % (key, value)
7753 
      for key, value in self.__dict__.iteritems()]
7754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7755 
 
7756 
  def __eq__(self, other):
7757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7758 
 
7759 
  def __ne__(self, other):
7760 
    return not (self == other)
7761 
 
3064 chandransh 7762 
class getOrdersForTransaction_args:
494 rajveer 7763 
  """
7764 
  Attributes:
3064 chandransh 7765 
   - transactionId
7766 
   - customerId
494 rajveer 7767 
  """
7768 
 
7769 
  thrift_spec = (
7770 
    None, # 0
3064 chandransh 7771 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7772 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7773 
  )
7774 
 
3064 chandransh 7775 
  def __init__(self, transactionId=None, customerId=None,):
7776 
    self.transactionId = transactionId
7777 
    self.customerId = customerId
494 rajveer 7778 
 
7779 
  def read(self, iprot):
7780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7782 
      return
7783 
    iprot.readStructBegin()
7784 
    while True:
7785 
      (fname, ftype, fid) = iprot.readFieldBegin()
7786 
      if ftype == TType.STOP:
7787 
        break
7788 
      if fid == 1:
7789 
        if ftype == TType.I64:
3064 chandransh 7790 
          self.transactionId = iprot.readI64();
494 rajveer 7791 
        else:
7792 
          iprot.skip(ftype)
7793 
      elif fid == 2:
3064 chandransh 7794 
        if ftype == TType.I64:
7795 
          self.customerId = iprot.readI64();
494 rajveer 7796 
        else:
7797 
          iprot.skip(ftype)
7798 
      else:
7799 
        iprot.skip(ftype)
7800 
      iprot.readFieldEnd()
7801 
    iprot.readStructEnd()
7802 
 
7803 
  def write(self, oprot):
7804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7806 
      return
3064 chandransh 7807 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7808 
    if self.transactionId is not None:
3064 chandransh 7809 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7810 
      oprot.writeI64(self.transactionId)
494 rajveer 7811 
      oprot.writeFieldEnd()
3431 rajveer 7812 
    if self.customerId is not None:
3064 chandransh 7813 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7814 
      oprot.writeI64(self.customerId)
494 rajveer 7815 
      oprot.writeFieldEnd()
7816 
    oprot.writeFieldStop()
7817 
    oprot.writeStructEnd()
7818 
 
3431 rajveer 7819 
  def validate(self):
7820 
    return
7821 
 
7822 
 
494 rajveer 7823 
  def __repr__(self):
7824 
    L = ['%s=%r' % (key, value)
7825 
      for key, value in self.__dict__.iteritems()]
7826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7827 
 
7828 
  def __eq__(self, other):
7829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7830 
 
7831 
  def __ne__(self, other):
7832 
    return not (self == other)
7833 
 
3064 chandransh 7834 
class getOrdersForTransaction_result:
494 rajveer 7835 
  """
7836 
  Attributes:
7837 
   - success
7838 
   - ex
7839 
  """
7840 
 
7841 
  thrift_spec = (
3064 chandransh 7842 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7844 
  )
7845 
 
7846 
  def __init__(self, success=None, ex=None,):
7847 
    self.success = success
7848 
    self.ex = ex
7849 
 
7850 
  def read(self, iprot):
7851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7853 
      return
7854 
    iprot.readStructBegin()
7855 
    while True:
7856 
      (fname, ftype, fid) = iprot.readFieldBegin()
7857 
      if ftype == TType.STOP:
7858 
        break
7859 
      if fid == 0:
3064 chandransh 7860 
        if ftype == TType.LIST:
7861 
          self.success = []
4133 chandransh 7862 
          (_etype87, _size84) = iprot.readListBegin()
7863 
          for _i88 in xrange(_size84):
7864 
            _elem89 = Order()
7865 
            _elem89.read(iprot)
7866 
            self.success.append(_elem89)
3064 chandransh 7867 
          iprot.readListEnd()
494 rajveer 7868 
        else:
7869 
          iprot.skip(ftype)
7870 
      elif fid == 1:
7871 
        if ftype == TType.STRUCT:
7872 
          self.ex = TransactionServiceException()
7873 
          self.ex.read(iprot)
7874 
        else:
7875 
          iprot.skip(ftype)
7876 
      else:
7877 
        iprot.skip(ftype)
7878 
      iprot.readFieldEnd()
7879 
    iprot.readStructEnd()
7880 
 
7881 
  def write(self, oprot):
7882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7884 
      return
3064 chandransh 7885 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7886 
    if self.success is not None:
3064 chandransh 7887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7889 
      for iter90 in self.success:
7890 
        iter90.write(oprot)
3064 chandransh 7891 
      oprot.writeListEnd()
494 rajveer 7892 
      oprot.writeFieldEnd()
3431 rajveer 7893 
    if self.ex is not None:
494 rajveer 7894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7895 
      self.ex.write(oprot)
7896 
      oprot.writeFieldEnd()
7897 
    oprot.writeFieldStop()
7898 
    oprot.writeStructEnd()
7899 
 
3431 rajveer 7900 
  def validate(self):
7901 
    return
7902 
 
7903 
 
494 rajveer 7904 
  def __repr__(self):
7905 
    L = ['%s=%r' % (key, value)
7906 
      for key, value in self.__dict__.iteritems()]
7907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7908 
 
7909 
  def __eq__(self, other):
7910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7911 
 
7912 
  def __ne__(self, other):
7913 
    return not (self == other)
7914 
 
3064 chandransh 7915 
class getOrdersForCustomer_args:
1149 chandransh 7916 
  """
7917 
  Attributes:
3064 chandransh 7918 
   - customerId
7919 
   - from_date
7920 
   - to_date
7921 
   - statuses
1149 chandransh 7922 
  """
7923 
 
7924 
  thrift_spec = (
7925 
    None, # 0
3064 chandransh 7926 
    (1, TType.I64, 'customerId', None, None, ), # 1
7927 
    (2, TType.I64, 'from_date', None, None, ), # 2
7928 
    (3, TType.I64, 'to_date', None, None, ), # 3
7929 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7930 
  )
7931 
 
3064 chandransh 7932 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7933 
    self.customerId = customerId
7934 
    self.from_date = from_date
7935 
    self.to_date = to_date
7936 
    self.statuses = statuses
1149 chandransh 7937 
 
7938 
  def read(self, iprot):
7939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7941 
      return
7942 
    iprot.readStructBegin()
7943 
    while True:
7944 
      (fname, ftype, fid) = iprot.readFieldBegin()
7945 
      if ftype == TType.STOP:
7946 
        break
7947 
      if fid == 1:
7948 
        if ftype == TType.I64:
3064 chandransh 7949 
          self.customerId = iprot.readI64();
1149 chandransh 7950 
        else:
7951 
          iprot.skip(ftype)
7952 
      elif fid == 2:
7953 
        if ftype == TType.I64:
3064 chandransh 7954 
          self.from_date = iprot.readI64();
1149 chandransh 7955 
        else:
7956 
          iprot.skip(ftype)
2783 chandransh 7957 
      elif fid == 3:
7958 
        if ftype == TType.I64:
3064 chandransh 7959 
          self.to_date = iprot.readI64();
2783 chandransh 7960 
        else:
7961 
          iprot.skip(ftype)
7962 
      elif fid == 4:
3064 chandransh 7963 
        if ftype == TType.LIST:
7964 
          self.statuses = []
4133 chandransh 7965 
          (_etype94, _size91) = iprot.readListBegin()
7966 
          for _i95 in xrange(_size91):
7967 
            _elem96 = iprot.readI32();
7968 
            self.statuses.append(_elem96)
3064 chandransh 7969 
          iprot.readListEnd()
2783 chandransh 7970 
        else:
7971 
          iprot.skip(ftype)
1149 chandransh 7972 
      else:
7973 
        iprot.skip(ftype)
7974 
      iprot.readFieldEnd()
7975 
    iprot.readStructEnd()
7976 
 
7977 
  def write(self, oprot):
7978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7980 
      return
3064 chandransh 7981 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7982 
    if self.customerId is not None:
3064 chandransh 7983 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7984 
      oprot.writeI64(self.customerId)
1149 chandransh 7985 
      oprot.writeFieldEnd()
3431 rajveer 7986 
    if self.from_date is not None:
3064 chandransh 7987 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7988 
      oprot.writeI64(self.from_date)
1149 chandransh 7989 
      oprot.writeFieldEnd()
3431 rajveer 7990 
    if self.to_date is not None:
3064 chandransh 7991 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7992 
      oprot.writeI64(self.to_date)
2783 chandransh 7993 
      oprot.writeFieldEnd()
3431 rajveer 7994 
    if self.statuses is not None:
3064 chandransh 7995 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7996 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7997 
      for iter97 in self.statuses:
7998 
        oprot.writeI32(iter97)
3064 chandransh 7999 
      oprot.writeListEnd()
2783 chandransh 8000 
      oprot.writeFieldEnd()
1149 chandransh 8001 
    oprot.writeFieldStop()
8002 
    oprot.writeStructEnd()
8003 
 
3431 rajveer 8004 
  def validate(self):
8005 
    return
8006 
 
8007 
 
1149 chandransh 8008 
  def __repr__(self):
8009 
    L = ['%s=%r' % (key, value)
8010 
      for key, value in self.__dict__.iteritems()]
8011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8012 
 
8013 
  def __eq__(self, other):
8014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8015 
 
8016 
  def __ne__(self, other):
8017 
    return not (self == other)
8018 
 
3064 chandransh 8019 
class getOrdersForCustomer_result:
1149 chandransh 8020 
  """
8021 
  Attributes:
8022 
   - success
8023 
   - ex
8024 
  """
8025 
 
8026 
  thrift_spec = (
3064 chandransh 8027 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8029 
  )
8030 
 
8031 
  def __init__(self, success=None, ex=None,):
8032 
    self.success = success
8033 
    self.ex = ex
8034 
 
8035 
  def read(self, iprot):
8036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8038 
      return
8039 
    iprot.readStructBegin()
8040 
    while True:
8041 
      (fname, ftype, fid) = iprot.readFieldBegin()
8042 
      if ftype == TType.STOP:
8043 
        break
8044 
      if fid == 0:
3064 chandransh 8045 
        if ftype == TType.LIST:
8046 
          self.success = []
4133 chandransh 8047 
          (_etype101, _size98) = iprot.readListBegin()
8048 
          for _i102 in xrange(_size98):
8049 
            _elem103 = Order()
8050 
            _elem103.read(iprot)
8051 
            self.success.append(_elem103)
3064 chandransh 8052 
          iprot.readListEnd()
1149 chandransh 8053 
        else:
8054 
          iprot.skip(ftype)
8055 
      elif fid == 1:
8056 
        if ftype == TType.STRUCT:
8057 
          self.ex = TransactionServiceException()
8058 
          self.ex.read(iprot)
8059 
        else:
8060 
          iprot.skip(ftype)
8061 
      else:
8062 
        iprot.skip(ftype)
8063 
      iprot.readFieldEnd()
8064 
    iprot.readStructEnd()
8065 
 
8066 
  def write(self, oprot):
8067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8069 
      return
3064 chandransh 8070 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8071 
    if self.success is not None:
3064 chandransh 8072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8074 
      for iter104 in self.success:
8075 
        iter104.write(oprot)
3064 chandransh 8076 
      oprot.writeListEnd()
1149 chandransh 8077 
      oprot.writeFieldEnd()
3431 rajveer 8078 
    if self.ex is not None:
1149 chandransh 8079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8080 
      self.ex.write(oprot)
8081 
      oprot.writeFieldEnd()
8082 
    oprot.writeFieldStop()
8083 
    oprot.writeStructEnd()
8084 
 
3431 rajveer 8085 
  def validate(self):
8086 
    return
8087 
 
8088 
 
1149 chandransh 8089 
  def __repr__(self):
8090 
    L = ['%s=%r' % (key, value)
8091 
      for key, value in self.__dict__.iteritems()]
8092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8093 
 
8094 
  def __eq__(self, other):
8095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8096 
 
8097 
  def __ne__(self, other):
8098 
    return not (self == other)
8099 
 
3064 chandransh 8100 
class createOrder_args:
921 rajveer 8101 
  """
8102 
  Attributes:
3064 chandransh 8103 
   - order
921 rajveer 8104 
  """
8105 
 
8106 
  thrift_spec = (
8107 
    None, # 0
3064 chandransh 8108 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8109 
  )
8110 
 
3064 chandransh 8111 
  def __init__(self, order=None,):
8112 
    self.order = order
921 rajveer 8113 
 
8114 
  def read(self, iprot):
8115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8117 
      return
8118 
    iprot.readStructBegin()
8119 
    while True:
8120 
      (fname, ftype, fid) = iprot.readFieldBegin()
8121 
      if ftype == TType.STOP:
8122 
        break
8123 
      if fid == 1:
3064 chandransh 8124 
        if ftype == TType.STRUCT:
8125 
          self.order = Order()
8126 
          self.order.read(iprot)
921 rajveer 8127 
        else:
8128 
          iprot.skip(ftype)
8129 
      else:
8130 
        iprot.skip(ftype)
8131 
      iprot.readFieldEnd()
8132 
    iprot.readStructEnd()
8133 
 
8134 
  def write(self, oprot):
8135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8137 
      return
3064 chandransh 8138 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8139 
    if self.order is not None:
3064 chandransh 8140 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8141 
      self.order.write(oprot)
921 rajveer 8142 
      oprot.writeFieldEnd()
8143 
    oprot.writeFieldStop()
8144 
    oprot.writeStructEnd()
8145 
 
3431 rajveer 8146 
  def validate(self):
8147 
    return
8148 
 
8149 
 
921 rajveer 8150 
  def __repr__(self):
8151 
    L = ['%s=%r' % (key, value)
8152 
      for key, value in self.__dict__.iteritems()]
8153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8154 
 
8155 
  def __eq__(self, other):
8156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8157 
 
8158 
  def __ne__(self, other):
8159 
    return not (self == other)
8160 
 
3064 chandransh 8161 
class createOrder_result:
921 rajveer 8162 
  """
8163 
  Attributes:
8164 
   - success
8165 
   - ex
8166 
  """
8167 
 
8168 
  thrift_spec = (
3064 chandransh 8169 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8171 
  )
8172 
 
8173 
  def __init__(self, success=None, ex=None,):
8174 
    self.success = success
8175 
    self.ex = ex
8176 
 
8177 
  def read(self, iprot):
8178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8180 
      return
8181 
    iprot.readStructBegin()
8182 
    while True:
8183 
      (fname, ftype, fid) = iprot.readFieldBegin()
8184 
      if ftype == TType.STOP:
8185 
        break
8186 
      if fid == 0:
3064 chandransh 8187 
        if ftype == TType.I64:
8188 
          self.success = iprot.readI64();
921 rajveer 8189 
        else:
8190 
          iprot.skip(ftype)
8191 
      elif fid == 1:
8192 
        if ftype == TType.STRUCT:
8193 
          self.ex = TransactionServiceException()
8194 
          self.ex.read(iprot)
8195 
        else:
8196 
          iprot.skip(ftype)
8197 
      else:
8198 
        iprot.skip(ftype)
8199 
      iprot.readFieldEnd()
8200 
    iprot.readStructEnd()
8201 
 
8202 
  def write(self, oprot):
8203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8205 
      return
3064 chandransh 8206 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8207 
    if self.success is not None:
3064 chandransh 8208 
      oprot.writeFieldBegin('success', TType.I64, 0)
8209 
      oprot.writeI64(self.success)
921 rajveer 8210 
      oprot.writeFieldEnd()
3431 rajveer 8211 
    if self.ex is not None:
921 rajveer 8212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8213 
      self.ex.write(oprot)
8214 
      oprot.writeFieldEnd()
8215 
    oprot.writeFieldStop()
8216 
    oprot.writeStructEnd()
8217 
 
3431 rajveer 8218 
  def validate(self):
8219 
    return
8220 
 
8221 
 
921 rajveer 8222 
  def __repr__(self):
8223 
    L = ['%s=%r' % (key, value)
8224 
      for key, value in self.__dict__.iteritems()]
8225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8226 
 
8227 
  def __eq__(self, other):
8228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8229 
 
8230 
  def __ne__(self, other):
8231 
    return not (self == other)
8232 
 
3064 chandransh 8233 
class getOrder_args:
921 rajveer 8234 
  """
8235 
  Attributes:
3064 chandransh 8236 
   - id
921 rajveer 8237 
  """
8238 
 
8239 
  thrift_spec = (
8240 
    None, # 0
3064 chandransh 8241 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8242 
  )
8243 
 
3064 chandransh 8244 
  def __init__(self, id=None,):
8245 
    self.id = id
921 rajveer 8246 
 
8247 
  def read(self, iprot):
8248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8250 
      return
8251 
    iprot.readStructBegin()
8252 
    while True:
8253 
      (fname, ftype, fid) = iprot.readFieldBegin()
8254 
      if ftype == TType.STOP:
8255 
        break
8256 
      if fid == 1:
8257 
        if ftype == TType.I64:
3064 chandransh 8258 
          self.id = iprot.readI64();
921 rajveer 8259 
        else:
8260 
          iprot.skip(ftype)
8261 
      else:
8262 
        iprot.skip(ftype)
8263 
      iprot.readFieldEnd()
8264 
    iprot.readStructEnd()
8265 
 
8266 
  def write(self, oprot):
8267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8269 
      return
3064 chandransh 8270 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8271 
    if self.id is not None:
3064 chandransh 8272 
      oprot.writeFieldBegin('id', TType.I64, 1)
8273 
      oprot.writeI64(self.id)
921 rajveer 8274 
      oprot.writeFieldEnd()
8275 
    oprot.writeFieldStop()
8276 
    oprot.writeStructEnd()
8277 
 
3431 rajveer 8278 
  def validate(self):
8279 
    return
8280 
 
8281 
 
921 rajveer 8282 
  def __repr__(self):
8283 
    L = ['%s=%r' % (key, value)
8284 
      for key, value in self.__dict__.iteritems()]
8285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8286 
 
8287 
  def __eq__(self, other):
8288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8289 
 
8290 
  def __ne__(self, other):
8291 
    return not (self == other)
8292 
 
3064 chandransh 8293 
class getOrder_result:
921 rajveer 8294 
  """
8295 
  Attributes:
8296 
   - success
8297 
   - ex
8298 
  """
8299 
 
8300 
  thrift_spec = (
3064 chandransh 8301 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8303 
  )
8304 
 
8305 
  def __init__(self, success=None, ex=None,):
8306 
    self.success = success
8307 
    self.ex = ex
8308 
 
8309 
  def read(self, iprot):
8310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8312 
      return
8313 
    iprot.readStructBegin()
8314 
    while True:
8315 
      (fname, ftype, fid) = iprot.readFieldBegin()
8316 
      if ftype == TType.STOP:
8317 
        break
8318 
      if fid == 0:
3064 chandransh 8319 
        if ftype == TType.STRUCT:
8320 
          self.success = Order()
8321 
          self.success.read(iprot)
921 rajveer 8322 
        else:
8323 
          iprot.skip(ftype)
8324 
      elif fid == 1:
8325 
        if ftype == TType.STRUCT:
8326 
          self.ex = TransactionServiceException()
8327 
          self.ex.read(iprot)
8328 
        else:
8329 
          iprot.skip(ftype)
8330 
      else:
8331 
        iprot.skip(ftype)
8332 
      iprot.readFieldEnd()
8333 
    iprot.readStructEnd()
8334 
 
8335 
  def write(self, oprot):
8336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8338 
      return
3064 chandransh 8339 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8340 
    if self.success is not None:
3064 chandransh 8341 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8342 
      self.success.write(oprot)
921 rajveer 8343 
      oprot.writeFieldEnd()
3431 rajveer 8344 
    if self.ex is not None:
921 rajveer 8345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8346 
      self.ex.write(oprot)
8347 
      oprot.writeFieldEnd()
8348 
    oprot.writeFieldStop()
8349 
    oprot.writeStructEnd()
8350 
 
3431 rajveer 8351 
  def validate(self):
8352 
    return
8353 
 
8354 
 
921 rajveer 8355 
  def __repr__(self):
8356 
    L = ['%s=%r' % (key, value)
8357 
      for key, value in self.__dict__.iteritems()]
8358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8359 
 
8360 
  def __eq__(self, other):
8361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8362 
 
8363 
  def __ne__(self, other):
8364 
    return not (self == other)
8365 
 
3064 chandransh 8366 
class getLineItemsForOrder_args:
94 ashish 8367 
  """
8368 
  Attributes:
3064 chandransh 8369 
   - orderId
94 ashish 8370 
  """
8371 
 
8372 
  thrift_spec = (
8373 
    None, # 0
3064 chandransh 8374 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8375 
  )
8376 
 
3064 chandransh 8377 
  def __init__(self, orderId=None,):
8378 
    self.orderId = orderId
94 ashish 8379 
 
8380 
  def read(self, iprot):
8381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8383 
      return
8384 
    iprot.readStructBegin()
8385 
    while True:
8386 
      (fname, ftype, fid) = iprot.readFieldBegin()
8387 
      if ftype == TType.STOP:
8388 
        break
8389 
      if fid == 1:
8390 
        if ftype == TType.I64:
3064 chandransh 8391 
          self.orderId = iprot.readI64();
94 ashish 8392 
        else:
8393 
          iprot.skip(ftype)
8394 
      else:
8395 
        iprot.skip(ftype)
8396 
      iprot.readFieldEnd()
8397 
    iprot.readStructEnd()
8398 
 
8399 
  def write(self, oprot):
8400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8402 
      return
3064 chandransh 8403 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8404 
    if self.orderId is not None:
3064 chandransh 8405 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8406 
      oprot.writeI64(self.orderId)
94 ashish 8407 
      oprot.writeFieldEnd()
8408 
    oprot.writeFieldStop()
8409 
    oprot.writeStructEnd()
8410 
 
3431 rajveer 8411 
  def validate(self):
8412 
    return
8413 
 
8414 
 
94 ashish 8415 
  def __repr__(self):
8416 
    L = ['%s=%r' % (key, value)
8417 
      for key, value in self.__dict__.iteritems()]
8418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8419 
 
8420 
  def __eq__(self, other):
8421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8422 
 
8423 
  def __ne__(self, other):
8424 
    return not (self == other)
8425 
 
3064 chandransh 8426 
class getLineItemsForOrder_result:
94 ashish 8427 
  """
8428 
  Attributes:
8429 
   - success
8430 
   - ex
8431 
  """
8432 
 
8433 
  thrift_spec = (
3064 chandransh 8434 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8436 
  )
8437 
 
8438 
  def __init__(self, success=None, ex=None,):
8439 
    self.success = success
8440 
    self.ex = ex
8441 
 
8442 
  def read(self, iprot):
8443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8445 
      return
8446 
    iprot.readStructBegin()
8447 
    while True:
8448 
      (fname, ftype, fid) = iprot.readFieldBegin()
8449 
      if ftype == TType.STOP:
8450 
        break
8451 
      if fid == 0:
483 rajveer 8452 
        if ftype == TType.LIST:
8453 
          self.success = []
4133 chandransh 8454 
          (_etype108, _size105) = iprot.readListBegin()
8455 
          for _i109 in xrange(_size105):
8456 
            _elem110 = LineItem()
8457 
            _elem110.read(iprot)
8458 
            self.success.append(_elem110)
483 rajveer 8459 
          iprot.readListEnd()
94 ashish 8460 
        else:
8461 
          iprot.skip(ftype)
8462 
      elif fid == 1:
8463 
        if ftype == TType.STRUCT:
8464 
          self.ex = TransactionServiceException()
8465 
          self.ex.read(iprot)
8466 
        else:
8467 
          iprot.skip(ftype)
8468 
      else:
8469 
        iprot.skip(ftype)
8470 
      iprot.readFieldEnd()
8471 
    iprot.readStructEnd()
8472 
 
8473 
  def write(self, oprot):
8474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8476 
      return
3064 chandransh 8477 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8478 
    if self.success is not None:
483 rajveer 8479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8481 
      for iter111 in self.success:
8482 
        iter111.write(oprot)
483 rajveer 8483 
      oprot.writeListEnd()
94 ashish 8484 
      oprot.writeFieldEnd()
3431 rajveer 8485 
    if self.ex is not None:
94 ashish 8486 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8487 
      self.ex.write(oprot)
8488 
      oprot.writeFieldEnd()
8489 
    oprot.writeFieldStop()
8490 
    oprot.writeStructEnd()
8491 
 
3431 rajveer 8492 
  def validate(self):
8493 
    return
8494 
 
8495 
 
94 ashish 8496 
  def __repr__(self):
8497 
    L = ['%s=%r' % (key, value)
8498 
      for key, value in self.__dict__.iteritems()]
8499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8500 
 
8501 
  def __eq__(self, other):
8502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8503 
 
8504 
  def __ne__(self, other):
8505 
    return not (self == other)
8506 
 
3064 chandransh 8507 
class getOrderForCustomer_args:
94 ashish 8508 
  """
8509 
  Attributes:
3064 chandransh 8510 
   - orderId
483 rajveer 8511 
   - customerId
94 ashish 8512 
  """
8513 
 
8514 
  thrift_spec = (
8515 
    None, # 0
3064 chandransh 8516 
    (1, TType.I64, 'orderId', None, None, ), # 1
8517 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8518 
  )
8519 
 
3064 chandransh 8520 
  def __init__(self, orderId=None, customerId=None,):
8521 
    self.orderId = orderId
483 rajveer 8522 
    self.customerId = customerId
94 ashish 8523 
 
8524 
  def read(self, iprot):
8525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8527 
      return
8528 
    iprot.readStructBegin()
8529 
    while True:
8530 
      (fname, ftype, fid) = iprot.readFieldBegin()
8531 
      if ftype == TType.STOP:
8532 
        break
8533 
      if fid == 1:
8534 
        if ftype == TType.I64:
3064 chandransh 8535 
          self.orderId = iprot.readI64();
94 ashish 8536 
        else:
8537 
          iprot.skip(ftype)
8538 
      elif fid == 2:
8539 
        if ftype == TType.I64:
3064 chandransh 8540 
          self.customerId = iprot.readI64();
94 ashish 8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      else:
8544 
        iprot.skip(ftype)
8545 
      iprot.readFieldEnd()
8546 
    iprot.readStructEnd()
8547 
 
8548 
  def write(self, oprot):
8549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8551 
      return
3064 chandransh 8552 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8553 
    if self.orderId is not None:
3064 chandransh 8554 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8555 
      oprot.writeI64(self.orderId)
8556 
      oprot.writeFieldEnd()
3431 rajveer 8557 
    if self.customerId is not None:
3064 chandransh 8558 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8559 
      oprot.writeI64(self.customerId)
94 ashish 8560 
      oprot.writeFieldEnd()
8561 
    oprot.writeFieldStop()
8562 
    oprot.writeStructEnd()
8563 
 
3431 rajveer 8564 
  def validate(self):
8565 
    return
8566 
 
8567 
 
94 ashish 8568 
  def __repr__(self):
8569 
    L = ['%s=%r' % (key, value)
8570 
      for key, value in self.__dict__.iteritems()]
8571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8572 
 
8573 
  def __eq__(self, other):
8574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8575 
 
8576 
  def __ne__(self, other):
8577 
    return not (self == other)
8578 
 
3064 chandransh 8579 
class getOrderForCustomer_result:
94 ashish 8580 
  """
8581 
  Attributes:
8582 
   - success
8583 
   - ex
8584 
  """
8585 
 
8586 
  thrift_spec = (
3064 chandransh 8587 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8589 
  )
8590 
 
8591 
  def __init__(self, success=None, ex=None,):
8592 
    self.success = success
8593 
    self.ex = ex
8594 
 
8595 
  def read(self, iprot):
8596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8598 
      return
8599 
    iprot.readStructBegin()
8600 
    while True:
8601 
      (fname, ftype, fid) = iprot.readFieldBegin()
8602 
      if ftype == TType.STOP:
8603 
        break
8604 
      if fid == 0:
3064 chandransh 8605 
        if ftype == TType.STRUCT:
8606 
          self.success = Order()
8607 
          self.success.read(iprot)
94 ashish 8608 
        else:
8609 
          iprot.skip(ftype)
8610 
      elif fid == 1:
8611 
        if ftype == TType.STRUCT:
8612 
          self.ex = TransactionServiceException()
8613 
          self.ex.read(iprot)
8614 
        else:
8615 
          iprot.skip(ftype)
8616 
      else:
8617 
        iprot.skip(ftype)
8618 
      iprot.readFieldEnd()
8619 
    iprot.readStructEnd()
8620 
 
8621 
  def write(self, oprot):
8622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8624 
      return
3064 chandransh 8625 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8626 
    if self.success is not None:
3064 chandransh 8627 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8628 
      self.success.write(oprot)
94 ashish 8629 
      oprot.writeFieldEnd()
3431 rajveer 8630 
    if self.ex is not None:
94 ashish 8631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8632 
      self.ex.write(oprot)
8633 
      oprot.writeFieldEnd()
8634 
    oprot.writeFieldStop()
8635 
    oprot.writeStructEnd()
8636 
 
3431 rajveer 8637 
  def validate(self):
8638 
    return
8639 
 
8640 
 
94 ashish 8641 
  def __repr__(self):
8642 
    L = ['%s=%r' % (key, value)
8643 
      for key, value in self.__dict__.iteritems()]
8644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8645 
 
8646 
  def __eq__(self, other):
8647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8648 
 
8649 
  def __ne__(self, other):
8650 
    return not (self == other)
8651 
 
3064 chandransh 8652 
class getAlerts_args:
94 ashish 8653 
  """
8654 
  Attributes:
4394 rajveer 8655 
   - type
4444 rajveer 8656 
   - warehouseId
4394 rajveer 8657 
   - status
8658 
   - timestamp
94 ashish 8659 
  """
8660 
 
8661 
  thrift_spec = (
8662 
    None, # 0
4394 rajveer 8663 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8664 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8665 
    (3, TType.I64, 'status', None, None, ), # 3
8666 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8667 
  )
8668 
 
4444 rajveer 8669 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8670 
    self.type = type
4444 rajveer 8671 
    self.warehouseId = warehouseId
4394 rajveer 8672 
    self.status = status
8673 
    self.timestamp = timestamp
94 ashish 8674 
 
8675 
  def read(self, iprot):
8676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8678 
      return
8679 
    iprot.readStructBegin()
8680 
    while True:
8681 
      (fname, ftype, fid) = iprot.readFieldBegin()
8682 
      if ftype == TType.STOP:
8683 
        break
8684 
      if fid == 1:
3064 chandransh 8685 
        if ftype == TType.I64:
4394 rajveer 8686 
          self.type = iprot.readI64();
94 ashish 8687 
        else:
8688 
          iprot.skip(ftype)
3064 chandransh 8689 
      elif fid == 2:
4394 rajveer 8690 
        if ftype == TType.I64:
4444 rajveer 8691 
          self.warehouseId = iprot.readI64();
3064 chandransh 8692 
        else:
8693 
          iprot.skip(ftype)
4394 rajveer 8694 
      elif fid == 3:
8695 
        if ftype == TType.I64:
4444 rajveer 8696 
          self.status = iprot.readI64();
8697 
        else:
8698 
          iprot.skip(ftype)
8699 
      elif fid == 4:
8700 
        if ftype == TType.I64:
4394 rajveer 8701 
          self.timestamp = iprot.readI64();
8702 
        else:
8703 
          iprot.skip(ftype)
94 ashish 8704 
      else:
8705 
        iprot.skip(ftype)
8706 
      iprot.readFieldEnd()
8707 
    iprot.readStructEnd()
8708 
 
8709 
  def write(self, oprot):
8710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8712 
      return
3064 chandransh 8713 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8714 
    if self.type is not None:
8715 
      oprot.writeFieldBegin('type', TType.I64, 1)
8716 
      oprot.writeI64(self.type)
94 ashish 8717 
      oprot.writeFieldEnd()
4444 rajveer 8718 
    if self.warehouseId is not None:
8719 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8720 
      oprot.writeI64(self.warehouseId)
8721 
      oprot.writeFieldEnd()
4394 rajveer 8722 
    if self.status is not None:
4444 rajveer 8723 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8724 
      oprot.writeI64(self.status)
3064 chandransh 8725 
      oprot.writeFieldEnd()
4394 rajveer 8726 
    if self.timestamp is not None:
4444 rajveer 8727 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8728 
      oprot.writeI64(self.timestamp)
8729 
      oprot.writeFieldEnd()
94 ashish 8730 
    oprot.writeFieldStop()
8731 
    oprot.writeStructEnd()
8732 
 
3431 rajveer 8733 
  def validate(self):
8734 
    return
8735 
 
8736 
 
94 ashish 8737 
  def __repr__(self):
8738 
    L = ['%s=%r' % (key, value)
8739 
      for key, value in self.__dict__.iteritems()]
8740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8741 
 
8742 
  def __eq__(self, other):
8743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8744 
 
8745 
  def __ne__(self, other):
8746 
    return not (self == other)
8747 
 
3064 chandransh 8748 
class getAlerts_result:
94 ashish 8749 
  """
8750 
  Attributes:
8751 
   - success
8752 
  """
8753 
 
8754 
  thrift_spec = (
3064 chandransh 8755 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8756 
  )
8757 
 
3064 chandransh 8758 
  def __init__(self, success=None,):
94 ashish 8759 
    self.success = success
8760 
 
8761 
  def read(self, iprot):
8762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8764 
      return
8765 
    iprot.readStructBegin()
8766 
    while True:
8767 
      (fname, ftype, fid) = iprot.readFieldBegin()
8768 
      if ftype == TType.STOP:
8769 
        break
8770 
      if fid == 0:
3064 chandransh 8771 
        if ftype == TType.LIST:
8772 
          self.success = []
4133 chandransh 8773 
          (_etype115, _size112) = iprot.readListBegin()
8774 
          for _i116 in xrange(_size112):
8775 
            _elem117 = Alert()
8776 
            _elem117.read(iprot)
8777 
            self.success.append(_elem117)
3064 chandransh 8778 
          iprot.readListEnd()
94 ashish 8779 
        else:
8780 
          iprot.skip(ftype)
8781 
      else:
8782 
        iprot.skip(ftype)
8783 
      iprot.readFieldEnd()
8784 
    iprot.readStructEnd()
8785 
 
8786 
  def write(self, oprot):
8787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8789 
      return
3064 chandransh 8790 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8791 
    if self.success is not None:
3064 chandransh 8792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8794 
      for iter118 in self.success:
8795 
        iter118.write(oprot)
3064 chandransh 8796 
      oprot.writeListEnd()
94 ashish 8797 
      oprot.writeFieldEnd()
8798 
    oprot.writeFieldStop()
8799 
    oprot.writeStructEnd()
8800 
 
3431 rajveer 8801 
  def validate(self):
8802 
    return
8803 
 
8804 
 
94 ashish 8805 
  def __repr__(self):
8806 
    L = ['%s=%r' % (key, value)
8807 
      for key, value in self.__dict__.iteritems()]
8808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8809 
 
8810 
  def __eq__(self, other):
8811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8812 
 
8813 
  def __ne__(self, other):
8814 
    return not (self == other)
8815 
 
4394 rajveer 8816 
class addAlert_args:
94 ashish 8817 
  """
8818 
  Attributes:
3064 chandransh 8819 
   - type
4444 rajveer 8820 
   - warehouseId
4394 rajveer 8821 
   - description
94 ashish 8822 
  """
8823 
 
8824 
  thrift_spec = (
8825 
    None, # 0
4394 rajveer 8826 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8827 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8828 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8829 
  )
8830 
 
4444 rajveer 8831 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8832 
    self.type = type
4444 rajveer 8833 
    self.warehouseId = warehouseId
4394 rajveer 8834 
    self.description = description
94 ashish 8835 
 
8836 
  def read(self, iprot):
8837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8839 
      return
8840 
    iprot.readStructBegin()
8841 
    while True:
8842 
      (fname, ftype, fid) = iprot.readFieldBegin()
8843 
      if ftype == TType.STOP:
8844 
        break
8845 
      if fid == 1:
8846 
        if ftype == TType.I64:
4394 rajveer 8847 
          self.type = iprot.readI64();
94 ashish 8848 
        else:
8849 
          iprot.skip(ftype)
3064 chandransh 8850 
      elif fid == 2:
4444 rajveer 8851 
        if ftype == TType.I64:
8852 
          self.warehouseId = iprot.readI64();
8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      elif fid == 3:
3064 chandransh 8856 
        if ftype == TType.STRING:
4394 rajveer 8857 
          self.description = iprot.readString();
3064 chandransh 8858 
        else:
8859 
          iprot.skip(ftype)
94 ashish 8860 
      else:
8861 
        iprot.skip(ftype)
8862 
      iprot.readFieldEnd()
8863 
    iprot.readStructEnd()
8864 
 
8865 
  def write(self, oprot):
8866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8868 
      return
4394 rajveer 8869 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8870 
    if self.type is not None:
4394 rajveer 8871 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8872 
      oprot.writeI64(self.type)
8873 
      oprot.writeFieldEnd()
4444 rajveer 8874 
    if self.warehouseId is not None:
8875 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8876 
      oprot.writeI64(self.warehouseId)
8877 
      oprot.writeFieldEnd()
4394 rajveer 8878 
    if self.description is not None:
4444 rajveer 8879 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8880 
      oprot.writeString(self.description)
3064 chandransh 8881 
      oprot.writeFieldEnd()
94 ashish 8882 
    oprot.writeFieldStop()
8883 
    oprot.writeStructEnd()
8884 
 
3431 rajveer 8885 
  def validate(self):
8886 
    return
8887 
 
8888 
 
94 ashish 8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
4394 rajveer 8900 
class addAlert_result:
3064 chandransh 8901 
 
8902 
  thrift_spec = (
8903 
  )
8904 
 
8905 
  def read(self, iprot):
8906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8908 
      return
8909 
    iprot.readStructBegin()
8910 
    while True:
8911 
      (fname, ftype, fid) = iprot.readFieldBegin()
8912 
      if ftype == TType.STOP:
8913 
        break
8914 
      else:
8915 
        iprot.skip(ftype)
8916 
      iprot.readFieldEnd()
8917 
    iprot.readStructEnd()
8918 
 
8919 
  def write(self, oprot):
8920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8922 
      return
4394 rajveer 8923 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8924 
    oprot.writeFieldStop()
8925 
    oprot.writeStructEnd()
8926 
 
3431 rajveer 8927 
  def validate(self):
8928 
    return
8929 
 
8930 
 
3064 chandransh 8931 
  def __repr__(self):
8932 
    L = ['%s=%r' % (key, value)
8933 
      for key, value in self.__dict__.iteritems()]
8934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8935 
 
8936 
  def __eq__(self, other):
8937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8938 
 
8939 
  def __ne__(self, other):
8940 
    return not (self == other)
8941 
 
4444 rajveer 8942 
class markAlertsAsSeen_args:
8943 
  """
8944 
  Attributes:
8945 
   - warehouseId
8946 
  """
8947 
 
8948 
  thrift_spec = (
8949 
    None, # 0
8950 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8951 
  )
8952 
 
8953 
  def __init__(self, warehouseId=None,):
8954 
    self.warehouseId = warehouseId
8955 
 
8956 
  def read(self, iprot):
8957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8959 
      return
8960 
    iprot.readStructBegin()
8961 
    while True:
8962 
      (fname, ftype, fid) = iprot.readFieldBegin()
8963 
      if ftype == TType.STOP:
8964 
        break
8965 
      if fid == 1:
8966 
        if ftype == TType.I64:
8967 
          self.warehouseId = iprot.readI64();
8968 
        else:
8969 
          iprot.skip(ftype)
8970 
      else:
8971 
        iprot.skip(ftype)
8972 
      iprot.readFieldEnd()
8973 
    iprot.readStructEnd()
8974 
 
8975 
  def write(self, oprot):
8976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8978 
      return
8979 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8980 
    if self.warehouseId is not None:
8981 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8982 
      oprot.writeI64(self.warehouseId)
8983 
      oprot.writeFieldEnd()
8984 
    oprot.writeFieldStop()
8985 
    oprot.writeStructEnd()
8986 
 
8987 
  def validate(self):
8988 
    return
8989 
 
8990 
 
8991 
  def __repr__(self):
8992 
    L = ['%s=%r' % (key, value)
8993 
      for key, value in self.__dict__.iteritems()]
8994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8995 
 
8996 
  def __eq__(self, other):
8997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8998 
 
8999 
  def __ne__(self, other):
9000 
    return not (self == other)
9001 
 
9002 
class markAlertsAsSeen_result:
9003 
 
9004 
  thrift_spec = (
9005 
  )
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      else:
9017 
        iprot.skip(ftype)
9018 
      iprot.readFieldEnd()
9019 
    iprot.readStructEnd()
9020 
 
9021 
  def write(self, oprot):
9022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9024 
      return
9025 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9026 
    oprot.writeFieldStop()
9027 
    oprot.writeStructEnd()
9028 
 
9029 
  def validate(self):
9030 
    return
9031 
 
9032 
 
9033 
  def __repr__(self):
9034 
    L = ['%s=%r' % (key, value)
9035 
      for key, value in self.__dict__.iteritems()]
9036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9037 
 
9038 
  def __eq__(self, other):
9039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9040 
 
9041 
  def __ne__(self, other):
9042 
    return not (self == other)
9043 
 
3064 chandransh 9044 
class getValidOrderCount_args:
9045 
 
9046 
  thrift_spec = (
9047 
  )
9048 
 
9049 
  def read(self, iprot):
9050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9052 
      return
9053 
    iprot.readStructBegin()
9054 
    while True:
9055 
      (fname, ftype, fid) = iprot.readFieldBegin()
9056 
      if ftype == TType.STOP:
9057 
        break
9058 
      else:
9059 
        iprot.skip(ftype)
9060 
      iprot.readFieldEnd()
9061 
    iprot.readStructEnd()
9062 
 
9063 
  def write(self, oprot):
9064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9066 
      return
9067 
    oprot.writeStructBegin('getValidOrderCount_args')
9068 
    oprot.writeFieldStop()
9069 
    oprot.writeStructEnd()
9070 
 
3431 rajveer 9071 
  def validate(self):
9072 
    return
9073 
 
9074 
 
3064 chandransh 9075 
  def __repr__(self):
9076 
    L = ['%s=%r' % (key, value)
9077 
      for key, value in self.__dict__.iteritems()]
9078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9079 
 
9080 
  def __eq__(self, other):
9081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9082 
 
9083 
  def __ne__(self, other):
9084 
    return not (self == other)
9085 
 
9086 
class getValidOrderCount_result:
94 ashish 9087 
  """
9088 
  Attributes:
9089 
   - success
9090 
  """
9091 
 
9092 
  thrift_spec = (
3064 chandransh 9093 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9094 
  )
9095 
 
3064 chandransh 9096 
  def __init__(self, success=None,):
94 ashish 9097 
    self.success = success
9098 
 
9099 
  def read(self, iprot):
9100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9102 
      return
9103 
    iprot.readStructBegin()
9104 
    while True:
9105 
      (fname, ftype, fid) = iprot.readFieldBegin()
9106 
      if ftype == TType.STOP:
9107 
        break
9108 
      if fid == 0:
3064 chandransh 9109 
        if ftype == TType.I64:
9110 
          self.success = iprot.readI64();
94 ashish 9111 
        else:
9112 
          iprot.skip(ftype)
9113 
      else:
9114 
        iprot.skip(ftype)
9115 
      iprot.readFieldEnd()
9116 
    iprot.readStructEnd()
9117 
 
9118 
  def write(self, oprot):
9119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9121 
      return
3064 chandransh 9122 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9123 
    if self.success is not None:
3064 chandransh 9124 
      oprot.writeFieldBegin('success', TType.I64, 0)
9125 
      oprot.writeI64(self.success)
94 ashish 9126 
      oprot.writeFieldEnd()
9127 
    oprot.writeFieldStop()
9128 
    oprot.writeStructEnd()
9129 
 
3431 rajveer 9130 
  def validate(self):
9131 
    return
9132 
 
9133 
 
94 ashish 9134 
  def __repr__(self):
9135 
    L = ['%s=%r' % (key, value)
9136 
      for key, value in self.__dict__.iteritems()]
9137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9138 
 
9139 
  def __eq__(self, other):
9140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9141 
 
9142 
  def __ne__(self, other):
9143 
    return not (self == other)
9144 
 
3064 chandransh 9145 
class getNoOfCustomersWithSuccessfulTransaction_args:
9146 
 
9147 
  thrift_spec = (
9148 
  )
9149 
 
9150 
  def read(self, iprot):
9151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9153 
      return
9154 
    iprot.readStructBegin()
9155 
    while True:
9156 
      (fname, ftype, fid) = iprot.readFieldBegin()
9157 
      if ftype == TType.STOP:
9158 
        break
9159 
      else:
9160 
        iprot.skip(ftype)
9161 
      iprot.readFieldEnd()
9162 
    iprot.readStructEnd()
9163 
 
9164 
  def write(self, oprot):
9165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9167 
      return
9168 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9169 
    oprot.writeFieldStop()
9170 
    oprot.writeStructEnd()
9171 
 
3431 rajveer 9172 
  def validate(self):
9173 
    return
9174 
 
9175 
 
3064 chandransh 9176 
  def __repr__(self):
9177 
    L = ['%s=%r' % (key, value)
9178 
      for key, value in self.__dict__.iteritems()]
9179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9180 
 
9181 
  def __eq__(self, other):
9182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9183 
 
9184 
  def __ne__(self, other):
9185 
    return not (self == other)
9186 
 
9187 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9188 
  """
9189 
  Attributes:
3064 chandransh 9190 
   - success
94 ashish 9191 
  """
9192 
 
9193 
  thrift_spec = (
3064 chandransh 9194 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9195 
  )
9196 
 
3064 chandransh 9197 
  def __init__(self, success=None,):
9198 
    self.success = success
94 ashish 9199 
 
9200 
  def read(self, iprot):
9201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9203 
      return
9204 
    iprot.readStructBegin()
9205 
    while True:
9206 
      (fname, ftype, fid) = iprot.readFieldBegin()
9207 
      if ftype == TType.STOP:
9208 
        break
3064 chandransh 9209 
      if fid == 0:
94 ashish 9210 
        if ftype == TType.I64:
3064 chandransh 9211 
          self.success = iprot.readI64();
94 ashish 9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
3064 chandransh 9223 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9224 
    if self.success is not None:
3064 chandransh 9225 
      oprot.writeFieldBegin('success', TType.I64, 0)
9226 
      oprot.writeI64(self.success)
94 ashish 9227 
      oprot.writeFieldEnd()
9228 
    oprot.writeFieldStop()
9229 
    oprot.writeStructEnd()
9230 
 
3431 rajveer 9231 
  def validate(self):
9232 
    return
9233 
 
9234 
 
94 ashish 9235 
  def __repr__(self):
9236 
    L = ['%s=%r' % (key, value)
9237 
      for key, value in self.__dict__.iteritems()]
9238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9239 
 
9240 
  def __eq__(self, other):
9241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9242 
 
9243 
  def __ne__(self, other):
9244 
    return not (self == other)
9245 
 
3064 chandransh 9246 
class getValidOrdersAmountRange_args:
9247 
 
9248 
  thrift_spec = (
9249 
  )
9250 
 
9251 
  def read(self, iprot):
9252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9254 
      return
9255 
    iprot.readStructBegin()
9256 
    while True:
9257 
      (fname, ftype, fid) = iprot.readFieldBegin()
9258 
      if ftype == TType.STOP:
9259 
        break
9260 
      else:
9261 
        iprot.skip(ftype)
9262 
      iprot.readFieldEnd()
9263 
    iprot.readStructEnd()
9264 
 
9265 
  def write(self, oprot):
9266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9268 
      return
9269 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9270 
    oprot.writeFieldStop()
9271 
    oprot.writeStructEnd()
9272 
 
3431 rajveer 9273 
  def validate(self):
9274 
    return
9275 
 
9276 
 
3064 chandransh 9277 
  def __repr__(self):
9278 
    L = ['%s=%r' % (key, value)
9279 
      for key, value in self.__dict__.iteritems()]
9280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9281 
 
9282 
  def __eq__(self, other):
9283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9284 
 
9285 
  def __ne__(self, other):
9286 
    return not (self == other)
9287 
 
9288 
class getValidOrdersAmountRange_result:
94 ashish 9289 
  """
9290 
  Attributes:
9291 
   - success
9292 
  """
9293 
 
9294 
  thrift_spec = (
3064 chandransh 9295 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9296 
  )
9297 
 
3064 chandransh 9298 
  def __init__(self, success=None,):
94 ashish 9299 
    self.success = success
9300 
 
9301 
  def read(self, iprot):
9302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9304 
      return
9305 
    iprot.readStructBegin()
9306 
    while True:
9307 
      (fname, ftype, fid) = iprot.readFieldBegin()
9308 
      if ftype == TType.STOP:
9309 
        break
9310 
      if fid == 0:
483 rajveer 9311 
        if ftype == TType.LIST:
9312 
          self.success = []
4133 chandransh 9313 
          (_etype122, _size119) = iprot.readListBegin()
9314 
          for _i123 in xrange(_size119):
9315 
            _elem124 = iprot.readDouble();
9316 
            self.success.append(_elem124)
483 rajveer 9317 
          iprot.readListEnd()
94 ashish 9318 
        else:
9319 
          iprot.skip(ftype)
9320 
      else:
9321 
        iprot.skip(ftype)
9322 
      iprot.readFieldEnd()
9323 
    iprot.readStructEnd()
9324 
 
9325 
  def write(self, oprot):
9326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9328 
      return
3064 chandransh 9329 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9330 
    if self.success is not None:
483 rajveer 9331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9332 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9333 
      for iter125 in self.success:
9334 
        oprot.writeDouble(iter125)
483 rajveer 9335 
      oprot.writeListEnd()
94 ashish 9336 
      oprot.writeFieldEnd()
9337 
    oprot.writeFieldStop()
9338 
    oprot.writeStructEnd()
9339 
 
3431 rajveer 9340 
  def validate(self):
9341 
    return
9342 
 
9343 
 
94 ashish 9344 
  def __repr__(self):
9345 
    L = ['%s=%r' % (key, value)
9346 
      for key, value in self.__dict__.iteritems()]
9347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9348 
 
9349 
  def __eq__(self, other):
9350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9351 
 
9352 
  def __ne__(self, other):
9353 
    return not (self == other)
9354 
 
3064 chandransh 9355 
class getValidOrders_args:
1528 ankur.sing 9356 
  """
9357 
  Attributes:
3064 chandransh 9358 
   - limit
1528 ankur.sing 9359 
  """
9360 
 
9361 
  thrift_spec = (
9362 
    None, # 0
3064 chandransh 9363 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9364 
  )
9365 
 
3064 chandransh 9366 
  def __init__(self, limit=None,):
9367 
    self.limit = limit
1528 ankur.sing 9368 
 
9369 
  def read(self, iprot):
9370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9372 
      return
9373 
    iprot.readStructBegin()
9374 
    while True:
9375 
      (fname, ftype, fid) = iprot.readFieldBegin()
9376 
      if ftype == TType.STOP:
9377 
        break
9378 
      if fid == 1:
9379 
        if ftype == TType.I64:
3064 chandransh 9380 
          self.limit = iprot.readI64();
1528 ankur.sing 9381 
        else:
9382 
          iprot.skip(ftype)
9383 
      else:
9384 
        iprot.skip(ftype)
9385 
      iprot.readFieldEnd()
9386 
    iprot.readStructEnd()
9387 
 
9388 
  def write(self, oprot):
9389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9391 
      return
3064 chandransh 9392 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9393 
    if self.limit is not None:
3064 chandransh 9394 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9395 
      oprot.writeI64(self.limit)
1528 ankur.sing 9396 
      oprot.writeFieldEnd()
9397 
    oprot.writeFieldStop()
9398 
    oprot.writeStructEnd()
9399 
 
3431 rajveer 9400 
  def validate(self):
9401 
    return
9402 
 
9403 
 
1528 ankur.sing 9404 
  def __repr__(self):
9405 
    L = ['%s=%r' % (key, value)
9406 
      for key, value in self.__dict__.iteritems()]
9407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9408 
 
9409 
  def __eq__(self, other):
9410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9411 
 
9412 
  def __ne__(self, other):
9413 
    return not (self == other)
9414 
 
3064 chandransh 9415 
class getValidOrders_result:
1528 ankur.sing 9416 
  """
9417 
  Attributes:
9418 
   - success
9419 
  """
9420 
 
9421 
  thrift_spec = (
3064 chandransh 9422 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9423 
  )
9424 
 
3064 chandransh 9425 
  def __init__(self, success=None,):
1528 ankur.sing 9426 
    self.success = success
9427 
 
9428 
  def read(self, iprot):
9429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9431 
      return
9432 
    iprot.readStructBegin()
9433 
    while True:
9434 
      (fname, ftype, fid) = iprot.readFieldBegin()
9435 
      if ftype == TType.STOP:
9436 
        break
9437 
      if fid == 0:
3064 chandransh 9438 
        if ftype == TType.LIST:
9439 
          self.success = []
4133 chandransh 9440 
          (_etype129, _size126) = iprot.readListBegin()
9441 
          for _i130 in xrange(_size126):
9442 
            _elem131 = Order()
9443 
            _elem131.read(iprot)
9444 
            self.success.append(_elem131)
3064 chandransh 9445 
          iprot.readListEnd()
1528 ankur.sing 9446 
        else:
9447 
          iprot.skip(ftype)
9448 
      else:
9449 
        iprot.skip(ftype)
9450 
      iprot.readFieldEnd()
9451 
    iprot.readStructEnd()
9452 
 
9453 
  def write(self, oprot):
9454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9456 
      return
3064 chandransh 9457 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9458 
    if self.success is not None:
3064 chandransh 9459 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9460 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9461 
      for iter132 in self.success:
9462 
        iter132.write(oprot)
3064 chandransh 9463 
      oprot.writeListEnd()
1528 ankur.sing 9464 
      oprot.writeFieldEnd()
9465 
    oprot.writeFieldStop()
9466 
    oprot.writeStructEnd()
9467 
 
3431 rajveer 9468 
  def validate(self):
9469 
    return
9470 
 
9471 
 
1528 ankur.sing 9472 
  def __repr__(self):
9473 
    L = ['%s=%r' % (key, value)
9474 
      for key, value in self.__dict__.iteritems()]
9475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9476 
 
9477 
  def __eq__(self, other):
9478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9479 
 
9480 
  def __ne__(self, other):
9481 
    return not (self == other)
9482 
 
1220 chandransh 9483 
class batchOrders_args:
9484 
  """
9485 
  Attributes:
9486 
   - warehouseId
9487 
  """
9488 
 
9489 
  thrift_spec = (
9490 
    None, # 0
9491 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9492 
  )
9493 
 
9494 
  def __init__(self, warehouseId=None,):
9495 
    self.warehouseId = warehouseId
9496 
 
9497 
  def read(self, iprot):
9498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9500 
      return
9501 
    iprot.readStructBegin()
9502 
    while True:
9503 
      (fname, ftype, fid) = iprot.readFieldBegin()
9504 
      if ftype == TType.STOP:
9505 
        break
9506 
      if fid == 1:
9507 
        if ftype == TType.I64:
9508 
          self.warehouseId = iprot.readI64();
9509 
        else:
9510 
          iprot.skip(ftype)
9511 
      else:
9512 
        iprot.skip(ftype)
9513 
      iprot.readFieldEnd()
9514 
    iprot.readStructEnd()
9515 
 
9516 
  def write(self, oprot):
9517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9519 
      return
9520 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9521 
    if self.warehouseId is not None:
1220 chandransh 9522 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9523 
      oprot.writeI64(self.warehouseId)
9524 
      oprot.writeFieldEnd()
9525 
    oprot.writeFieldStop()
9526 
    oprot.writeStructEnd()
9527 
 
3431 rajveer 9528 
  def validate(self):
9529 
    return
9530 
 
9531 
 
1220 chandransh 9532 
  def __repr__(self):
9533 
    L = ['%s=%r' % (key, value)
9534 
      for key, value in self.__dict__.iteritems()]
9535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9536 
 
9537 
  def __eq__(self, other):
9538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9539 
 
9540 
  def __ne__(self, other):
9541 
    return not (self == other)
9542 
 
9543 
class batchOrders_result:
9544 
  """
9545 
  Attributes:
9546 
   - success
9547 
   - ex
9548 
  """
9549 
 
9550 
  thrift_spec = (
9551 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9553 
  )
9554 
 
9555 
  def __init__(self, success=None, ex=None,):
9556 
    self.success = success
9557 
    self.ex = ex
9558 
 
9559 
  def read(self, iprot):
9560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9562 
      return
9563 
    iprot.readStructBegin()
9564 
    while True:
9565 
      (fname, ftype, fid) = iprot.readFieldBegin()
9566 
      if ftype == TType.STOP:
9567 
        break
9568 
      if fid == 0:
9569 
        if ftype == TType.LIST:
9570 
          self.success = []
4133 chandransh 9571 
          (_etype136, _size133) = iprot.readListBegin()
9572 
          for _i137 in xrange(_size133):
9573 
            _elem138 = Order()
9574 
            _elem138.read(iprot)
9575 
            self.success.append(_elem138)
1220 chandransh 9576 
          iprot.readListEnd()
9577 
        else:
9578 
          iprot.skip(ftype)
9579 
      elif fid == 1:
9580 
        if ftype == TType.STRUCT:
9581 
          self.ex = TransactionServiceException()
9582 
          self.ex.read(iprot)
9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      else:
9586 
        iprot.skip(ftype)
9587 
      iprot.readFieldEnd()
9588 
    iprot.readStructEnd()
9589 
 
9590 
  def write(self, oprot):
9591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9593 
      return
9594 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9595 
    if self.success is not None:
1220 chandransh 9596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9597 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9598 
      for iter139 in self.success:
9599 
        iter139.write(oprot)
1220 chandransh 9600 
      oprot.writeListEnd()
9601 
      oprot.writeFieldEnd()
3431 rajveer 9602 
    if self.ex is not None:
1220 chandransh 9603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9604 
      self.ex.write(oprot)
9605 
      oprot.writeFieldEnd()
9606 
    oprot.writeFieldStop()
9607 
    oprot.writeStructEnd()
9608 
 
3431 rajveer 9609 
  def validate(self):
9610 
    return
9611 
 
9612 
 
1220 chandransh 9613 
  def __repr__(self):
9614 
    L = ['%s=%r' % (key, value)
9615 
      for key, value in self.__dict__.iteritems()]
9616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9617 
 
9618 
  def __eq__(self, other):
9619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9620 
 
9621 
  def __ne__(self, other):
9622 
    return not (self == other)
9623 
 
1208 chandransh 9624 
class markOrderAsOutOfStock_args:
9625 
  """
9626 
  Attributes:
9627 
   - orderId
9628 
  """
9629 
 
9630 
  thrift_spec = (
9631 
    None, # 0
9632 
    (1, TType.I64, 'orderId', None, None, ), # 1
9633 
  )
9634 
 
9635 
  def __init__(self, orderId=None,):
9636 
    self.orderId = orderId
9637 
 
9638 
  def read(self, iprot):
9639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9641 
      return
9642 
    iprot.readStructBegin()
9643 
    while True:
9644 
      (fname, ftype, fid) = iprot.readFieldBegin()
9645 
      if ftype == TType.STOP:
9646 
        break
9647 
      if fid == 1:
9648 
        if ftype == TType.I64:
9649 
          self.orderId = iprot.readI64();
9650 
        else:
9651 
          iprot.skip(ftype)
9652 
      else:
9653 
        iprot.skip(ftype)
9654 
      iprot.readFieldEnd()
9655 
    iprot.readStructEnd()
9656 
 
9657 
  def write(self, oprot):
9658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9660 
      return
9661 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9662 
    if self.orderId is not None:
1208 chandransh 9663 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9664 
      oprot.writeI64(self.orderId)
9665 
      oprot.writeFieldEnd()
9666 
    oprot.writeFieldStop()
9667 
    oprot.writeStructEnd()
9668 
 
3431 rajveer 9669 
  def validate(self):
9670 
    return
9671 
 
9672 
 
1208 chandransh 9673 
  def __repr__(self):
9674 
    L = ['%s=%r' % (key, value)
9675 
      for key, value in self.__dict__.iteritems()]
9676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9677 
 
9678 
  def __eq__(self, other):
9679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9680 
 
9681 
  def __ne__(self, other):
9682 
    return not (self == other)
9683 
 
9684 
class markOrderAsOutOfStock_result:
9685 
  """
9686 
  Attributes:
9687 
   - success
9688 
   - ex
9689 
  """
9690 
 
9691 
  thrift_spec = (
9692 
    (0, TType.BOOL, 'success', None, None, ), # 0
9693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9694 
  )
9695 
 
9696 
  def __init__(self, success=None, ex=None,):
9697 
    self.success = success
9698 
    self.ex = ex
9699 
 
9700 
  def read(self, iprot):
9701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9703 
      return
9704 
    iprot.readStructBegin()
9705 
    while True:
9706 
      (fname, ftype, fid) = iprot.readFieldBegin()
9707 
      if ftype == TType.STOP:
9708 
        break
9709 
      if fid == 0:
9710 
        if ftype == TType.BOOL:
9711 
          self.success = iprot.readBool();
9712 
        else:
9713 
          iprot.skip(ftype)
9714 
      elif fid == 1:
9715 
        if ftype == TType.STRUCT:
9716 
          self.ex = TransactionServiceException()
9717 
          self.ex.read(iprot)
9718 
        else:
9719 
          iprot.skip(ftype)
9720 
      else:
9721 
        iprot.skip(ftype)
9722 
      iprot.readFieldEnd()
9723 
    iprot.readStructEnd()
9724 
 
9725 
  def write(self, oprot):
9726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9728 
      return
9729 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9730 
    if self.success is not None:
1208 chandransh 9731 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9732 
      oprot.writeBool(self.success)
9733 
      oprot.writeFieldEnd()
3431 rajveer 9734 
    if self.ex is not None:
1208 chandransh 9735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9736 
      self.ex.write(oprot)
9737 
      oprot.writeFieldEnd()
9738 
    oprot.writeFieldStop()
9739 
    oprot.writeStructEnd()
9740 
 
3431 rajveer 9741 
  def validate(self):
9742 
    return
9743 
 
9744 
 
1208 chandransh 9745 
  def __repr__(self):
9746 
    L = ['%s=%r' % (key, value)
9747 
      for key, value in self.__dict__.iteritems()]
9748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9749 
 
9750 
  def __eq__(self, other):
9751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9752 
 
9753 
  def __ne__(self, other):
9754 
    return not (self == other)
9755 
 
3064 chandransh 9756 
class verifyOrder_args:
759 chandransh 9757 
  """
9758 
  Attributes:
3064 chandransh 9759 
   - orderId
759 chandransh 9760 
  """
9761 
 
9762 
  thrift_spec = (
9763 
    None, # 0
3064 chandransh 9764 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9765 
  )
9766 
 
3064 chandransh 9767 
  def __init__(self, orderId=None,):
9768 
    self.orderId = orderId
759 chandransh 9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 1:
9780 
        if ftype == TType.I64:
3064 chandransh 9781 
          self.orderId = iprot.readI64();
759 chandransh 9782 
        else:
9783 
          iprot.skip(ftype)
9784 
      else:
9785 
        iprot.skip(ftype)
9786 
      iprot.readFieldEnd()
9787 
    iprot.readStructEnd()
9788 
 
9789 
  def write(self, oprot):
9790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9792 
      return
3064 chandransh 9793 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9794 
    if self.orderId is not None:
3064 chandransh 9795 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9796 
      oprot.writeI64(self.orderId)
759 chandransh 9797 
      oprot.writeFieldEnd()
9798 
    oprot.writeFieldStop()
9799 
    oprot.writeStructEnd()
9800 
 
3431 rajveer 9801 
  def validate(self):
9802 
    return
9803 
 
9804 
 
759 chandransh 9805 
  def __repr__(self):
9806 
    L = ['%s=%r' % (key, value)
9807 
      for key, value in self.__dict__.iteritems()]
9808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9809 
 
9810 
  def __eq__(self, other):
9811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9812 
 
9813 
  def __ne__(self, other):
9814 
    return not (self == other)
9815 
 
3064 chandransh 9816 
class verifyOrder_result:
759 chandransh 9817 
  """
9818 
  Attributes:
9819 
   - success
9820 
   - ex
9821 
  """
9822 
 
9823 
  thrift_spec = (
9824 
    (0, TType.BOOL, 'success', None, None, ), # 0
9825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9826 
  )
9827 
 
9828 
  def __init__(self, success=None, ex=None,):
9829 
    self.success = success
9830 
    self.ex = ex
9831 
 
9832 
  def read(self, iprot):
9833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9835 
      return
9836 
    iprot.readStructBegin()
9837 
    while True:
9838 
      (fname, ftype, fid) = iprot.readFieldBegin()
9839 
      if ftype == TType.STOP:
9840 
        break
9841 
      if fid == 0:
9842 
        if ftype == TType.BOOL:
9843 
          self.success = iprot.readBool();
9844 
        else:
9845 
          iprot.skip(ftype)
9846 
      elif fid == 1:
9847 
        if ftype == TType.STRUCT:
9848 
          self.ex = TransactionServiceException()
9849 
          self.ex.read(iprot)
9850 
        else:
9851 
          iprot.skip(ftype)
9852 
      else:
9853 
        iprot.skip(ftype)
9854 
      iprot.readFieldEnd()
9855 
    iprot.readStructEnd()
9856 
 
9857 
  def write(self, oprot):
9858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9860 
      return
3064 chandransh 9861 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9862 
    if self.success is not None:
759 chandransh 9863 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9864 
      oprot.writeBool(self.success)
9865 
      oprot.writeFieldEnd()
3431 rajveer 9866 
    if self.ex is not None:
759 chandransh 9867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9868 
      self.ex.write(oprot)
9869 
      oprot.writeFieldEnd()
9870 
    oprot.writeFieldStop()
9871 
    oprot.writeStructEnd()
9872 
 
3431 rajveer 9873 
  def validate(self):
9874 
    return
9875 
 
9876 
 
759 chandransh 9877 
  def __repr__(self):
9878 
    L = ['%s=%r' % (key, value)
9879 
      for key, value in self.__dict__.iteritems()]
9880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9881 
 
9882 
  def __eq__(self, other):
9883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9884 
 
9885 
  def __ne__(self, other):
9886 
    return not (self == other)
9887 
 
3064 chandransh 9888 
class acceptOrder_args:
1113 chandransh 9889 
  """
9890 
  Attributes:
3064 chandransh 9891 
   - orderId
1113 chandransh 9892 
  """
9893 
 
9894 
  thrift_spec = (
9895 
    None, # 0
3064 chandransh 9896 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9897 
  )
9898 
 
3064 chandransh 9899 
  def __init__(self, orderId=None,):
9900 
    self.orderId = orderId
1113 chandransh 9901 
 
9902 
  def read(self, iprot):
9903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9905 
      return
9906 
    iprot.readStructBegin()
9907 
    while True:
9908 
      (fname, ftype, fid) = iprot.readFieldBegin()
9909 
      if ftype == TType.STOP:
9910 
        break
9911 
      if fid == 1:
9912 
        if ftype == TType.I64:
3064 chandransh 9913 
          self.orderId = iprot.readI64();
1113 chandransh 9914 
        else:
9915 
          iprot.skip(ftype)
9916 
      else:
9917 
        iprot.skip(ftype)
9918 
      iprot.readFieldEnd()
9919 
    iprot.readStructEnd()
9920 
 
9921 
  def write(self, oprot):
9922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9924 
      return
3064 chandransh 9925 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9926 
    if self.orderId is not None:
3064 chandransh 9927 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9928 
      oprot.writeI64(self.orderId)
1113 chandransh 9929 
      oprot.writeFieldEnd()
9930 
    oprot.writeFieldStop()
9931 
    oprot.writeStructEnd()
9932 
 
3431 rajveer 9933 
  def validate(self):
9934 
    return
9935 
 
9936 
 
1113 chandransh 9937 
  def __repr__(self):
9938 
    L = ['%s=%r' % (key, value)
9939 
      for key, value in self.__dict__.iteritems()]
9940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9941 
 
9942 
  def __eq__(self, other):
9943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9944 
 
9945 
  def __ne__(self, other):
9946 
    return not (self == other)
9947 
 
3064 chandransh 9948 
class acceptOrder_result:
1113 chandransh 9949 
  """
9950 
  Attributes:
9951 
   - success
9952 
   - ex
9953 
  """
9954 
 
9955 
  thrift_spec = (
3064 chandransh 9956 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9958 
  )
9959 
 
9960 
  def __init__(self, success=None, ex=None,):
9961 
    self.success = success
9962 
    self.ex = ex
9963 
 
9964 
  def read(self, iprot):
9965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9967 
      return
9968 
    iprot.readStructBegin()
9969 
    while True:
9970 
      (fname, ftype, fid) = iprot.readFieldBegin()
9971 
      if ftype == TType.STOP:
9972 
        break
9973 
      if fid == 0:
3064 chandransh 9974 
        if ftype == TType.BOOL:
9975 
          self.success = iprot.readBool();
1113 chandransh 9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      elif fid == 1:
9979 
        if ftype == TType.STRUCT:
9980 
          self.ex = TransactionServiceException()
9981 
          self.ex.read(iprot)
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      else:
9985 
        iprot.skip(ftype)
9986 
      iprot.readFieldEnd()
9987 
    iprot.readStructEnd()
9988 
 
9989 
  def write(self, oprot):
9990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9992 
      return
3064 chandransh 9993 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9994 
    if self.success is not None:
3064 chandransh 9995 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9996 
      oprot.writeBool(self.success)
1113 chandransh 9997 
      oprot.writeFieldEnd()
3431 rajveer 9998 
    if self.ex is not None:
1113 chandransh 9999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10000 
      self.ex.write(oprot)
10001 
      oprot.writeFieldEnd()
10002 
    oprot.writeFieldStop()
10003 
    oprot.writeStructEnd()
10004 
 
3431 rajveer 10005 
  def validate(self):
10006 
    return
10007 
 
10008 
 
1113 chandransh 10009 
  def __repr__(self):
10010 
    L = ['%s=%r' % (key, value)
10011 
      for key, value in self.__dict__.iteritems()]
10012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10013 
 
10014 
  def __eq__(self, other):
10015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10016 
 
10017 
  def __ne__(self, other):
10018 
    return not (self == other)
10019 
 
3064 chandransh 10020 
class addBillingDetails_args:
1135 chandransh 10021 
  """
10022 
  Attributes:
3064 chandransh 10023 
   - orderId
10024 
   - invoice_number
4283 anupam.sin 10025 
   - imeiNumber
10026 
   - itemNumber
3064 chandransh 10027 
   - billed_by
4264 rajveer 10028 
   - jacketNumber
4283 anupam.sin 10029 
   - billingType
10030 
   - vendorId
1135 chandransh 10031 
  """
10032 
 
10033 
  thrift_spec = (
10034 
    None, # 0
3064 chandransh 10035 
    (1, TType.I64, 'orderId', None, None, ), # 1
10036 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 10037 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
10038 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10039 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10040 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10041 
    (7, TType.I64, 'billingType', None, None, ), # 7
10042 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10043 
  )
10044 
 
4283 anupam.sin 10045 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10046 
    self.orderId = orderId
10047 
    self.invoice_number = invoice_number
4283 anupam.sin 10048 
    self.imeiNumber = imeiNumber
10049 
    self.itemNumber = itemNumber
3064 chandransh 10050 
    self.billed_by = billed_by
4264 rajveer 10051 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10052 
    self.billingType = billingType
10053 
    self.vendorId = vendorId
1135 chandransh 10054 
 
10055 
  def read(self, iprot):
10056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10058 
      return
10059 
    iprot.readStructBegin()
10060 
    while True:
10061 
      (fname, ftype, fid) = iprot.readFieldBegin()
10062 
      if ftype == TType.STOP:
10063 
        break
10064 
      if fid == 1:
10065 
        if ftype == TType.I64:
3064 chandransh 10066 
          self.orderId = iprot.readI64();
1135 chandransh 10067 
        else:
10068 
          iprot.skip(ftype)
10069 
      elif fid == 2:
3064 chandransh 10070 
        if ftype == TType.STRING:
10071 
          self.invoice_number = iprot.readString();
1135 chandransh 10072 
        else:
10073 
          iprot.skip(ftype)
3064 chandransh 10074 
      elif fid == 3:
4264 rajveer 10075 
        if ftype == TType.I64:
3064 chandransh 10076 
          self.imeiNumber = iprot.readI64();
10077 
        else:
10078 
          iprot.skip(ftype)
10079 
      elif fid == 4:
10080 
        if ftype == TType.STRING:
10081 
          self.itemNumber = iprot.readString();
10082 
        else:
10083 
          iprot.skip(ftype)
10084 
      elif fid == 5:
10085 
        if ftype == TType.STRING:
4283 anupam.sin 10086 
          self.billed_by = iprot.readString();
3064 chandransh 10087 
        else:
10088 
          iprot.skip(ftype)
10089 
      elif fid == 6:
10090 
        if ftype == TType.I64:
4283 anupam.sin 10091 
          self.jacketNumber = iprot.readI64();
10092 
        else:
10093 
          iprot.skip(ftype)
10094 
      elif fid == 7:
10095 
        if ftype == TType.I64:
3064 chandransh 10096 
          self.billingType = iprot.readI64();
10097 
        else:
10098 
          iprot.skip(ftype)
4283 anupam.sin 10099 
      elif fid == 8:
10100 
        if ftype == TType.I64:
10101 
          self.vendorId = iprot.readI64();
10102 
        else:
10103 
          iprot.skip(ftype)
1246 chandransh 10104 
      else:
10105 
        iprot.skip(ftype)
10106 
      iprot.readFieldEnd()
10107 
    iprot.readStructEnd()
10108 
 
10109 
  def write(self, oprot):
10110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10112 
      return
4283 anupam.sin 10113 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10114 
    if self.orderId is not None:
3064 chandransh 10115 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10116 
      oprot.writeI64(self.orderId)
1246 chandransh 10117 
      oprot.writeFieldEnd()
4283 anupam.sin 10118 
    if self.invoice_number is not None:
10119 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10120 
      oprot.writeString(self.invoice_number)
1246 chandransh 10121 
      oprot.writeFieldEnd()
3431 rajveer 10122 
    if self.imeiNumber is not None:
3064 chandransh 10123 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
10124 
      oprot.writeI64(self.imeiNumber)
10125 
      oprot.writeFieldEnd()
3431 rajveer 10126 
    if self.itemNumber is not None:
3064 chandransh 10127 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10128 
      oprot.writeString(self.itemNumber)
10129 
      oprot.writeFieldEnd()
4283 anupam.sin 10130 
    if self.billed_by is not None:
10131 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10132 
      oprot.writeString(self.billed_by)
3064 chandransh 10133 
      oprot.writeFieldEnd()
4283 anupam.sin 10134 
    if self.jacketNumber is not None:
10135 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10136 
      oprot.writeI64(self.jacketNumber)
10137 
      oprot.writeFieldEnd()
3431 rajveer 10138 
    if self.billingType is not None:
4283 anupam.sin 10139 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10140 
      oprot.writeI64(self.billingType)
10141 
      oprot.writeFieldEnd()
4283 anupam.sin 10142 
    if self.vendorId is not None:
10143 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10144 
      oprot.writeI64(self.vendorId)
10145 
      oprot.writeFieldEnd()
1246 chandransh 10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
1246 chandransh 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
4283 anupam.sin 10164 
class addBillingDetails_result:
1246 chandransh 10165 
  """
10166 
  Attributes:
3064 chandransh 10167 
   - success
1246 chandransh 10168 
   - ex
10169 
  """
10170 
 
10171 
  thrift_spec = (
3064 chandransh 10172 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10174 
  )
10175 
 
3064 chandransh 10176 
  def __init__(self, success=None, ex=None,):
10177 
    self.success = success
1246 chandransh 10178 
    self.ex = ex
10179 
 
10180 
  def read(self, iprot):
10181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10183 
      return
10184 
    iprot.readStructBegin()
10185 
    while True:
10186 
      (fname, ftype, fid) = iprot.readFieldBegin()
10187 
      if ftype == TType.STOP:
10188 
        break
3064 chandransh 10189 
      if fid == 0:
10190 
        if ftype == TType.BOOL:
10191 
          self.success = iprot.readBool();
10192 
        else:
10193 
          iprot.skip(ftype)
10194 
      elif fid == 1:
1246 chandransh 10195 
        if ftype == TType.STRUCT:
10196 
          self.ex = TransactionServiceException()
10197 
          self.ex.read(iprot)
10198 
        else:
10199 
          iprot.skip(ftype)
10200 
      else:
10201 
        iprot.skip(ftype)
10202 
      iprot.readFieldEnd()
10203 
    iprot.readStructEnd()
10204 
 
10205 
  def write(self, oprot):
10206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10208 
      return
4283 anupam.sin 10209 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10210 
    if self.success is not None:
3064 chandransh 10211 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10212 
      oprot.writeBool(self.success)
10213 
      oprot.writeFieldEnd()
3431 rajveer 10214 
    if self.ex is not None:
1246 chandransh 10215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10216 
      self.ex.write(oprot)
10217 
      oprot.writeFieldEnd()
10218 
    oprot.writeFieldStop()
10219 
    oprot.writeStructEnd()
10220 
 
3431 rajveer 10221 
  def validate(self):
10222 
    return
10223 
 
10224 
 
1246 chandransh 10225 
  def __repr__(self):
10226 
    L = ['%s=%r' % (key, value)
10227 
      for key, value in self.__dict__.iteritems()]
10228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10229 
 
10230 
  def __eq__(self, other):
10231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10232 
 
10233 
  def __ne__(self, other):
10234 
    return not (self == other)
10235 
 
4579 rajveer 10236 
class addInvoiceNumber_args:
10237 
  """
10238 
  Attributes:
10239 
   - orderId
10240 
   - invoiceNumber
10241 
  """
10242 
 
10243 
  thrift_spec = (
10244 
    None, # 0
10245 
    (1, TType.I64, 'orderId', None, None, ), # 1
10246 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10247 
  )
10248 
 
10249 
  def __init__(self, orderId=None, invoiceNumber=None,):
10250 
    self.orderId = orderId
10251 
    self.invoiceNumber = invoiceNumber
10252 
 
10253 
  def read(self, iprot):
10254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10256 
      return
10257 
    iprot.readStructBegin()
10258 
    while True:
10259 
      (fname, ftype, fid) = iprot.readFieldBegin()
10260 
      if ftype == TType.STOP:
10261 
        break
10262 
      if fid == 1:
10263 
        if ftype == TType.I64:
10264 
          self.orderId = iprot.readI64();
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      elif fid == 2:
10268 
        if ftype == TType.STRING:
10269 
          self.invoiceNumber = iprot.readString();
10270 
        else:
10271 
          iprot.skip(ftype)
10272 
      else:
10273 
        iprot.skip(ftype)
10274 
      iprot.readFieldEnd()
10275 
    iprot.readStructEnd()
10276 
 
10277 
  def write(self, oprot):
10278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10280 
      return
10281 
    oprot.writeStructBegin('addInvoiceNumber_args')
10282 
    if self.orderId is not None:
10283 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10284 
      oprot.writeI64(self.orderId)
10285 
      oprot.writeFieldEnd()
10286 
    if self.invoiceNumber is not None:
10287 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10288 
      oprot.writeString(self.invoiceNumber)
10289 
      oprot.writeFieldEnd()
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
10293 
  def validate(self):
10294 
    return
10295 
 
10296 
 
10297 
  def __repr__(self):
10298 
    L = ['%s=%r' % (key, value)
10299 
      for key, value in self.__dict__.iteritems()]
10300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10301 
 
10302 
  def __eq__(self, other):
10303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10304 
 
10305 
  def __ne__(self, other):
10306 
    return not (self == other)
10307 
 
10308 
class addInvoiceNumber_result:
10309 
  """
10310 
  Attributes:
10311 
   - ex
10312 
  """
10313 
 
10314 
  thrift_spec = (
10315 
    None, # 0
10316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10317 
  )
10318 
 
10319 
  def __init__(self, ex=None,):
10320 
    self.ex = ex
10321 
 
10322 
  def read(self, iprot):
10323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10325 
      return
10326 
    iprot.readStructBegin()
10327 
    while True:
10328 
      (fname, ftype, fid) = iprot.readFieldBegin()
10329 
      if ftype == TType.STOP:
10330 
        break
10331 
      if fid == 1:
10332 
        if ftype == TType.STRUCT:
10333 
          self.ex = TransactionServiceException()
10334 
          self.ex.read(iprot)
10335 
        else:
10336 
          iprot.skip(ftype)
10337 
      else:
10338 
        iprot.skip(ftype)
10339 
      iprot.readFieldEnd()
10340 
    iprot.readStructEnd()
10341 
 
10342 
  def write(self, oprot):
10343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10345 
      return
10346 
    oprot.writeStructBegin('addInvoiceNumber_result')
10347 
    if self.ex is not None:
10348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10349 
      self.ex.write(oprot)
10350 
      oprot.writeFieldEnd()
10351 
    oprot.writeFieldStop()
10352 
    oprot.writeStructEnd()
10353 
 
10354 
  def validate(self):
10355 
    return
10356 
 
10357 
 
10358 
  def __repr__(self):
10359 
    L = ['%s=%r' % (key, value)
10360 
      for key, value in self.__dict__.iteritems()]
10361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10362 
 
10363 
  def __eq__(self, other):
10364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10365 
 
10366 
  def __ne__(self, other):
10367 
    return not (self == other)
10368 
 
3064 chandransh 10369 
class markOrdersAsManifested_args:
1408 ankur.sing 10370 
  """
10371 
  Attributes:
3064 chandransh 10372 
   - warehouseId
1408 ankur.sing 10373 
   - providerId
3064 chandransh 10374 
   - cod
1408 ankur.sing 10375 
  """
10376 
 
10377 
  thrift_spec = (
10378 
    None, # 0
3064 chandransh 10379 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10380 
    (2, TType.I64, 'providerId', None, None, ), # 2
10381 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10382 
  )
10383 
 
3064 chandransh 10384 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10385 
    self.warehouseId = warehouseId
1408 ankur.sing 10386 
    self.providerId = providerId
3064 chandransh 10387 
    self.cod = cod
1408 ankur.sing 10388 
 
10389 
  def read(self, iprot):
10390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10392 
      return
10393 
    iprot.readStructBegin()
10394 
    while True:
10395 
      (fname, ftype, fid) = iprot.readFieldBegin()
10396 
      if ftype == TType.STOP:
10397 
        break
10398 
      if fid == 1:
10399 
        if ftype == TType.I64:
3064 chandransh 10400 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      elif fid == 2:
10404 
        if ftype == TType.I64:
3064 chandransh 10405 
          self.providerId = iprot.readI64();
1408 ankur.sing 10406 
        else:
10407 
          iprot.skip(ftype)
3064 chandransh 10408 
      elif fid == 3:
10409 
        if ftype == TType.BOOL:
10410 
          self.cod = iprot.readBool();
10411 
        else:
10412 
          iprot.skip(ftype)
1408 ankur.sing 10413 
      else:
10414 
        iprot.skip(ftype)
10415 
      iprot.readFieldEnd()
10416 
    iprot.readStructEnd()
10417 
 
10418 
  def write(self, oprot):
10419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10421 
      return
3064 chandransh 10422 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10423 
    if self.warehouseId is not None:
3064 chandransh 10424 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10425 
      oprot.writeI64(self.warehouseId)
10426 
      oprot.writeFieldEnd()
3431 rajveer 10427 
    if self.providerId is not None:
3064 chandransh 10428 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10429 
      oprot.writeI64(self.providerId)
10430 
      oprot.writeFieldEnd()
3431 rajveer 10431 
    if self.cod is not None:
3064 chandransh 10432 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10433 
      oprot.writeBool(self.cod)
1408 ankur.sing 10434 
      oprot.writeFieldEnd()
10435 
    oprot.writeFieldStop()
10436 
    oprot.writeStructEnd()
10437 
 
3431 rajveer 10438 
  def validate(self):
10439 
    return
10440 
 
10441 
 
1408 ankur.sing 10442 
  def __repr__(self):
10443 
    L = ['%s=%r' % (key, value)
10444 
      for key, value in self.__dict__.iteritems()]
10445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10446 
 
10447 
  def __eq__(self, other):
10448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10449 
 
10450 
  def __ne__(self, other):
10451 
    return not (self == other)
10452 
 
3064 chandransh 10453 
class markOrdersAsManifested_result:
1408 ankur.sing 10454 
  """
10455 
  Attributes:
10456 
   - success
3064 chandransh 10457 
   - ex
1408 ankur.sing 10458 
  """
10459 
 
10460 
  thrift_spec = (
3064 chandransh 10461 
    (0, TType.BOOL, 'success', None, None, ), # 0
10462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10463 
  )
10464 
 
3064 chandransh 10465 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10466 
    self.success = success
3064 chandransh 10467 
    self.ex = ex
1408 ankur.sing 10468 
 
10469 
  def read(self, iprot):
10470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10472 
      return
10473 
    iprot.readStructBegin()
10474 
    while True:
10475 
      (fname, ftype, fid) = iprot.readFieldBegin()
10476 
      if ftype == TType.STOP:
10477 
        break
10478 
      if fid == 0:
3064 chandransh 10479 
        if ftype == TType.BOOL:
10480 
          self.success = iprot.readBool();
1408 ankur.sing 10481 
        else:
10482 
          iprot.skip(ftype)
3064 chandransh 10483 
      elif fid == 1:
10484 
        if ftype == TType.STRUCT:
10485 
          self.ex = TransactionServiceException()
10486 
          self.ex.read(iprot)
10487 
        else:
10488 
          iprot.skip(ftype)
1408 ankur.sing 10489 
      else:
10490 
        iprot.skip(ftype)
10491 
      iprot.readFieldEnd()
10492 
    iprot.readStructEnd()
10493 
 
10494 
  def write(self, oprot):
10495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10497 
      return
3064 chandransh 10498 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10499 
    if self.success is not None:
3064 chandransh 10500 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10501 
      oprot.writeBool(self.success)
1408 ankur.sing 10502 
      oprot.writeFieldEnd()
3431 rajveer 10503 
    if self.ex is not None:
3064 chandransh 10504 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10505 
      self.ex.write(oprot)
10506 
      oprot.writeFieldEnd()
1408 ankur.sing 10507 
    oprot.writeFieldStop()
10508 
    oprot.writeStructEnd()
10509 
 
3431 rajveer 10510 
  def validate(self):
10511 
    return
10512 
 
10513 
 
1408 ankur.sing 10514 
  def __repr__(self):
10515 
    L = ['%s=%r' % (key, value)
10516 
      for key, value in self.__dict__.iteritems()]
10517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10518 
 
10519 
  def __eq__(self, other):
10520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10521 
 
10522 
  def __ne__(self, other):
10523 
    return not (self == other)
10524 
 
4410 rajveer 10525 
class markOrdersAsShippedFromWarehouse_args:
10526 
  """
10527 
  Attributes:
10528 
   - warehouseId
10529 
   - providerId
10530 
   - cod
10531 
  """
10532 
 
10533 
  thrift_spec = (
10534 
    None, # 0
10535 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10536 
    (2, TType.I64, 'providerId', None, None, ), # 2
10537 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10538 
  )
10539 
 
10540 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10541 
    self.warehouseId = warehouseId
10542 
    self.providerId = providerId
10543 
    self.cod = cod
10544 
 
10545 
  def read(self, iprot):
10546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10548 
      return
10549 
    iprot.readStructBegin()
10550 
    while True:
10551 
      (fname, ftype, fid) = iprot.readFieldBegin()
10552 
      if ftype == TType.STOP:
10553 
        break
10554 
      if fid == 1:
10555 
        if ftype == TType.I64:
10556 
          self.warehouseId = iprot.readI64();
10557 
        else:
10558 
          iprot.skip(ftype)
10559 
      elif fid == 2:
10560 
        if ftype == TType.I64:
10561 
          self.providerId = iprot.readI64();
10562 
        else:
10563 
          iprot.skip(ftype)
10564 
      elif fid == 3:
10565 
        if ftype == TType.BOOL:
10566 
          self.cod = iprot.readBool();
10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      else:
10570 
        iprot.skip(ftype)
10571 
      iprot.readFieldEnd()
10572 
    iprot.readStructEnd()
10573 
 
10574 
  def write(self, oprot):
10575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10577 
      return
10578 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10579 
    if self.warehouseId is not None:
10580 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10581 
      oprot.writeI64(self.warehouseId)
10582 
      oprot.writeFieldEnd()
10583 
    if self.providerId is not None:
10584 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10585 
      oprot.writeI64(self.providerId)
10586 
      oprot.writeFieldEnd()
10587 
    if self.cod is not None:
10588 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10589 
      oprot.writeBool(self.cod)
10590 
      oprot.writeFieldEnd()
10591 
    oprot.writeFieldStop()
10592 
    oprot.writeStructEnd()
10593 
 
10594 
  def validate(self):
10595 
    return
10596 
 
10597 
 
10598 
  def __repr__(self):
10599 
    L = ['%s=%r' % (key, value)
10600 
      for key, value in self.__dict__.iteritems()]
10601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10602 
 
10603 
  def __eq__(self, other):
10604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10605 
 
10606 
  def __ne__(self, other):
10607 
    return not (self == other)
10608 
 
10609 
class markOrdersAsShippedFromWarehouse_result:
10610 
  """
10611 
  Attributes:
10612 
   - success
10613 
   - ex
10614 
  """
10615 
 
10616 
  thrift_spec = (
10617 
    (0, TType.BOOL, 'success', None, None, ), # 0
10618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10619 
  )
10620 
 
10621 
  def __init__(self, success=None, ex=None,):
10622 
    self.success = success
10623 
    self.ex = ex
10624 
 
10625 
  def read(self, iprot):
10626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10628 
      return
10629 
    iprot.readStructBegin()
10630 
    while True:
10631 
      (fname, ftype, fid) = iprot.readFieldBegin()
10632 
      if ftype == TType.STOP:
10633 
        break
10634 
      if fid == 0:
10635 
        if ftype == TType.BOOL:
10636 
          self.success = iprot.readBool();
10637 
        else:
10638 
          iprot.skip(ftype)
10639 
      elif fid == 1:
10640 
        if ftype == TType.STRUCT:
10641 
          self.ex = TransactionServiceException()
10642 
          self.ex.read(iprot)
10643 
        else:
10644 
          iprot.skip(ftype)
10645 
      else:
10646 
        iprot.skip(ftype)
10647 
      iprot.readFieldEnd()
10648 
    iprot.readStructEnd()
10649 
 
10650 
  def write(self, oprot):
10651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10653 
      return
10654 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10655 
    if self.success is not None:
10656 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10657 
      oprot.writeBool(self.success)
10658 
      oprot.writeFieldEnd()
10659 
    if self.ex is not None:
10660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10661 
      self.ex.write(oprot)
10662 
      oprot.writeFieldEnd()
10663 
    oprot.writeFieldStop()
10664 
    oprot.writeStructEnd()
10665 
 
10666 
  def validate(self):
10667 
    return
10668 
 
10669 
 
10670 
  def __repr__(self):
10671 
    L = ['%s=%r' % (key, value)
10672 
      for key, value in self.__dict__.iteritems()]
10673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10674 
 
10675 
  def __eq__(self, other):
10676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10677 
 
10678 
  def __ne__(self, other):
10679 
    return not (self == other)
10680 
 
3064 chandransh 10681 
class markOrdersAsPickedUp_args:
304 ashish 10682 
  """
10683 
  Attributes:
3064 chandransh 10684 
   - providerId
10685 
   - pickupDetails
304 ashish 10686 
  """
94 ashish 10687 
 
304 ashish 10688 
  thrift_spec = (
10689 
    None, # 0
3064 chandransh 10690 
    (1, TType.I64, 'providerId', None, None, ), # 1
10691 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10692 
  )
10693 
 
3064 chandransh 10694 
  def __init__(self, providerId=None, pickupDetails=None,):
10695 
    self.providerId = providerId
10696 
    self.pickupDetails = pickupDetails
304 ashish 10697 
 
10698 
  def read(self, iprot):
10699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10701 
      return
10702 
    iprot.readStructBegin()
10703 
    while True:
10704 
      (fname, ftype, fid) = iprot.readFieldBegin()
10705 
      if ftype == TType.STOP:
10706 
        break
10707 
      if fid == 1:
10708 
        if ftype == TType.I64:
3064 chandransh 10709 
          self.providerId = iprot.readI64();
304 ashish 10710 
        else:
10711 
          iprot.skip(ftype)
10712 
      elif fid == 2:
3064 chandransh 10713 
        if ftype == TType.MAP:
10714 
          self.pickupDetails = {}
4133 chandransh 10715 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10716 
          for _i144 in xrange(_size140):
10717 
            _key145 = iprot.readString();
10718 
            _val146 = iprot.readString();
10719 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10720 
          iprot.readMapEnd()
304 ashish 10721 
        else:
10722 
          iprot.skip(ftype)
10723 
      else:
10724 
        iprot.skip(ftype)
10725 
      iprot.readFieldEnd()
10726 
    iprot.readStructEnd()
10727 
 
10728 
  def write(self, oprot):
10729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10731 
      return
3064 chandransh 10732 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10733 
    if self.providerId is not None:
3064 chandransh 10734 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10735 
      oprot.writeI64(self.providerId)
304 ashish 10736 
      oprot.writeFieldEnd()
3431 rajveer 10737 
    if self.pickupDetails is not None:
3064 chandransh 10738 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10739 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10740 
      for kiter147,viter148 in self.pickupDetails.items():
10741 
        oprot.writeString(kiter147)
10742 
        oprot.writeString(viter148)
3064 chandransh 10743 
      oprot.writeMapEnd()
304 ashish 10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
3431 rajveer 10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
304 ashish 10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
3064 chandransh 10763 
class markOrdersAsPickedUp_result:
304 ashish 10764 
  """
10765 
  Attributes:
10766 
   - success
3064 chandransh 10767 
   - ex
304 ashish 10768 
  """
10769 
 
10770 
  thrift_spec = (
3064 chandransh 10771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10773 
  )
10774 
 
3064 chandransh 10775 
  def __init__(self, success=None, ex=None,):
304 ashish 10776 
    self.success = success
3064 chandransh 10777 
    self.ex = ex
304 ashish 10778 
 
10779 
  def read(self, iprot):
10780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10782 
      return
10783 
    iprot.readStructBegin()
10784 
    while True:
10785 
      (fname, ftype, fid) = iprot.readFieldBegin()
10786 
      if ftype == TType.STOP:
10787 
        break
10788 
      if fid == 0:
10789 
        if ftype == TType.LIST:
10790 
          self.success = []
4133 chandransh 10791 
          (_etype152, _size149) = iprot.readListBegin()
10792 
          for _i153 in xrange(_size149):
10793 
            _elem154 = Order()
10794 
            _elem154.read(iprot)
10795 
            self.success.append(_elem154)
304 ashish 10796 
          iprot.readListEnd()
10797 
        else:
10798 
          iprot.skip(ftype)
3064 chandransh 10799 
      elif fid == 1:
10800 
        if ftype == TType.STRUCT:
10801 
          self.ex = TransactionServiceException()
10802 
          self.ex.read(iprot)
10803 
        else:
10804 
          iprot.skip(ftype)
304 ashish 10805 
      else:
10806 
        iprot.skip(ftype)
10807 
      iprot.readFieldEnd()
10808 
    iprot.readStructEnd()
10809 
 
10810 
  def write(self, oprot):
10811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10813 
      return
3064 chandransh 10814 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10815 
    if self.success is not None:
304 ashish 10816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10818 
      for iter155 in self.success:
10819 
        iter155.write(oprot)
304 ashish 10820 
      oprot.writeListEnd()
10821 
      oprot.writeFieldEnd()
3431 rajveer 10822 
    if self.ex is not None:
3064 chandransh 10823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10824 
      self.ex.write(oprot)
10825 
      oprot.writeFieldEnd()
304 ashish 10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
3431 rajveer 10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
304 ashish 10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
3064 chandransh 10844 
class markOrdersAsDelivered_args:
304 ashish 10845 
  """
10846 
  Attributes:
3064 chandransh 10847 
   - providerId
10848 
   - deliveredOrders
304 ashish 10849 
  """
10850 
 
10851 
  thrift_spec = (
10852 
    None, # 0
3064 chandransh 10853 
    (1, TType.I64, 'providerId', None, None, ), # 1
10854 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10855 
  )
10856 
 
3064 chandransh 10857 
  def __init__(self, providerId=None, deliveredOrders=None,):
10858 
    self.providerId = providerId
10859 
    self.deliveredOrders = deliveredOrders
304 ashish 10860 
 
10861 
  def read(self, iprot):
10862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10864 
      return
10865 
    iprot.readStructBegin()
10866 
    while True:
10867 
      (fname, ftype, fid) = iprot.readFieldBegin()
10868 
      if ftype == TType.STOP:
10869 
        break
10870 
      if fid == 1:
10871 
        if ftype == TType.I64:
3064 chandransh 10872 
          self.providerId = iprot.readI64();
304 ashish 10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      elif fid == 2:
3064 chandransh 10876 
        if ftype == TType.MAP:
10877 
          self.deliveredOrders = {}
4133 chandransh 10878 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10879 
          for _i160 in xrange(_size156):
10880 
            _key161 = iprot.readString();
10881 
            _val162 = iprot.readString();
10882 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10883 
          iprot.readMapEnd()
304 ashish 10884 
        else:
10885 
          iprot.skip(ftype)
10886 
      else:
10887 
        iprot.skip(ftype)
10888 
      iprot.readFieldEnd()
10889 
    iprot.readStructEnd()
10890 
 
10891 
  def write(self, oprot):
10892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10894 
      return
3064 chandransh 10895 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10896 
    if self.providerId is not None:
3064 chandransh 10897 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10898 
      oprot.writeI64(self.providerId)
304 ashish 10899 
      oprot.writeFieldEnd()
3431 rajveer 10900 
    if self.deliveredOrders is not None:
3064 chandransh 10901 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10902 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10903 
      for kiter163,viter164 in self.deliveredOrders.items():
10904 
        oprot.writeString(kiter163)
10905 
        oprot.writeString(viter164)
3064 chandransh 10906 
      oprot.writeMapEnd()
304 ashish 10907 
      oprot.writeFieldEnd()
10908 
    oprot.writeFieldStop()
10909 
    oprot.writeStructEnd()
10910 
 
3431 rajveer 10911 
  def validate(self):
10912 
    return
10913 
 
10914 
 
304 ashish 10915 
  def __repr__(self):
10916 
    L = ['%s=%r' % (key, value)
10917 
      for key, value in self.__dict__.iteritems()]
10918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10919 
 
10920 
  def __eq__(self, other):
10921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10922 
 
10923 
  def __ne__(self, other):
10924 
    return not (self == other)
10925 
 
3064 chandransh 10926 
class markOrdersAsDelivered_result:
10927 
  """
10928 
  Attributes:
10929 
   - ex
10930 
  """
304 ashish 10931 
 
10932 
  thrift_spec = (
3064 chandransh 10933 
    None, # 0
10934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10935 
  )
10936 
 
3064 chandransh 10937 
  def __init__(self, ex=None,):
10938 
    self.ex = ex
304 ashish 10939 
 
1596 ankur.sing 10940 
  def read(self, iprot):
10941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10943 
      return
10944 
    iprot.readStructBegin()
10945 
    while True:
10946 
      (fname, ftype, fid) = iprot.readFieldBegin()
10947 
      if ftype == TType.STOP:
10948 
        break
3064 chandransh 10949 
      if fid == 1:
10950 
        if ftype == TType.STRUCT:
10951 
          self.ex = TransactionServiceException()
10952 
          self.ex.read(iprot)
10953 
        else:
10954 
          iprot.skip(ftype)
1596 ankur.sing 10955 
      else:
10956 
        iprot.skip(ftype)
10957 
      iprot.readFieldEnd()
10958 
    iprot.readStructEnd()
10959 
 
10960 
  def write(self, oprot):
10961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10963 
      return
3064 chandransh 10964 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10965 
    if self.ex is not None:
3064 chandransh 10966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10967 
      self.ex.write(oprot)
10968 
      oprot.writeFieldEnd()
1596 ankur.sing 10969 
    oprot.writeFieldStop()
10970 
    oprot.writeStructEnd()
10971 
 
3431 rajveer 10972 
  def validate(self):
10973 
    return
10974 
 
10975 
 
1596 ankur.sing 10976 
  def __repr__(self):
10977 
    L = ['%s=%r' % (key, value)
10978 
      for key, value in self.__dict__.iteritems()]
10979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10980 
 
10981 
  def __eq__(self, other):
10982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10983 
 
10984 
  def __ne__(self, other):
10985 
    return not (self == other)
10986 
 
3064 chandransh 10987 
class markOrdersAsFailed_args:
1596 ankur.sing 10988 
  """
10989 
  Attributes:
3064 chandransh 10990 
   - providerId
10991 
   - returnedOrders
1596 ankur.sing 10992 
  """
10993 
 
10994 
  thrift_spec = (
3064 chandransh 10995 
    None, # 0
10996 
    (1, TType.I64, 'providerId', None, None, ), # 1
10997 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10998 
  )
10999 
 
3064 chandransh 11000 
  def __init__(self, providerId=None, returnedOrders=None,):
11001 
    self.providerId = providerId
11002 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11003 
 
11004 
  def read(self, iprot):
11005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11007 
      return
11008 
    iprot.readStructBegin()
11009 
    while True:
11010 
      (fname, ftype, fid) = iprot.readFieldBegin()
11011 
      if ftype == TType.STOP:
11012 
        break
3064 chandransh 11013 
      if fid == 1:
1596 ankur.sing 11014 
        if ftype == TType.I64:
3064 chandransh 11015 
          self.providerId = iprot.readI64();
1596 ankur.sing 11016 
        else:
11017 
          iprot.skip(ftype)
3064 chandransh 11018 
      elif fid == 2:
11019 
        if ftype == TType.MAP:
11020 
          self.returnedOrders = {}
4133 chandransh 11021 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11022 
          for _i169 in xrange(_size165):
11023 
            _key170 = iprot.readString();
11024 
            _val171 = iprot.readString();
11025 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11026 
          iprot.readMapEnd()
11027 
        else:
11028 
          iprot.skip(ftype)
1596 ankur.sing 11029 
      else:
11030 
        iprot.skip(ftype)
11031 
      iprot.readFieldEnd()
11032 
    iprot.readStructEnd()
11033 
 
11034 
  def write(self, oprot):
11035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11037 
      return
3064 chandransh 11038 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11039 
    if self.providerId is not None:
3064 chandransh 11040 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11041 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11042 
      oprot.writeFieldEnd()
3431 rajveer 11043 
    if self.returnedOrders is not None:
3064 chandransh 11044 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11045 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11046 
      for kiter172,viter173 in self.returnedOrders.items():
11047 
        oprot.writeString(kiter172)
11048 
        oprot.writeString(viter173)
3064 chandransh 11049 
      oprot.writeMapEnd()
11050 
      oprot.writeFieldEnd()
1596 ankur.sing 11051 
    oprot.writeFieldStop()
11052 
    oprot.writeStructEnd()
11053 
 
3431 rajveer 11054 
  def validate(self):
11055 
    return
11056 
 
11057 
 
1596 ankur.sing 11058 
  def __repr__(self):
11059 
    L = ['%s=%r' % (key, value)
11060 
      for key, value in self.__dict__.iteritems()]
11061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11062 
 
11063 
  def __eq__(self, other):
11064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11065 
 
11066 
  def __ne__(self, other):
11067 
    return not (self == other)
11068 
 
3064 chandransh 11069 
class markOrdersAsFailed_result:
11070 
  """
11071 
  Attributes:
11072 
   - ex
11073 
  """
1596 ankur.sing 11074 
 
1627 ankur.sing 11075 
  thrift_spec = (
3064 chandransh 11076 
    None, # 0
11077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11078 
  )
11079 
 
3064 chandransh 11080 
  def __init__(self, ex=None,):
11081 
    self.ex = ex
11082 
 
1627 ankur.sing 11083 
  def read(self, iprot):
11084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11086 
      return
11087 
    iprot.readStructBegin()
11088 
    while True:
11089 
      (fname, ftype, fid) = iprot.readFieldBegin()
11090 
      if ftype == TType.STOP:
11091 
        break
3064 chandransh 11092 
      if fid == 1:
11093 
        if ftype == TType.STRUCT:
11094 
          self.ex = TransactionServiceException()
11095 
          self.ex.read(iprot)
11096 
        else:
11097 
          iprot.skip(ftype)
1627 ankur.sing 11098 
      else:
11099 
        iprot.skip(ftype)
11100 
      iprot.readFieldEnd()
11101 
    iprot.readStructEnd()
11102 
 
11103 
  def write(self, oprot):
11104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11106 
      return
3064 chandransh 11107 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11108 
    if self.ex is not None:
3064 chandransh 11109 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11110 
      self.ex.write(oprot)
11111 
      oprot.writeFieldEnd()
1627 ankur.sing 11112 
    oprot.writeFieldStop()
11113 
    oprot.writeStructEnd()
11114 
 
3431 rajveer 11115 
  def validate(self):
11116 
    return
11117 
 
11118 
 
1627 ankur.sing 11119 
  def __repr__(self):
11120 
    L = ['%s=%r' % (key, value)
11121 
      for key, value in self.__dict__.iteritems()]
11122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11123 
 
11124 
  def __eq__(self, other):
11125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11126 
 
11127 
  def __ne__(self, other):
11128 
    return not (self == other)
11129 
 
3064 chandransh 11130 
class updateNonDeliveryReason_args:
1627 ankur.sing 11131 
  """
11132 
  Attributes:
3064 chandransh 11133 
   - providerId
11134 
   - undeliveredOrders
1627 ankur.sing 11135 
  """
11136 
 
11137 
  thrift_spec = (
3064 chandransh 11138 
    None, # 0
11139 
    (1, TType.I64, 'providerId', None, None, ), # 1
11140 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11141 
  )
11142 
 
3064 chandransh 11143 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11144 
    self.providerId = providerId
11145 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11146 
 
11147 
  def read(self, iprot):
11148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11150 
      return
11151 
    iprot.readStructBegin()
11152 
    while True:
11153 
      (fname, ftype, fid) = iprot.readFieldBegin()
11154 
      if ftype == TType.STOP:
11155 
        break
3064 chandransh 11156 
      if fid == 1:
1627 ankur.sing 11157 
        if ftype == TType.I64:
3064 chandransh 11158 
          self.providerId = iprot.readI64();
1627 ankur.sing 11159 
        else:
11160 
          iprot.skip(ftype)
3064 chandransh 11161 
      elif fid == 2:
11162 
        if ftype == TType.MAP:
11163 
          self.undeliveredOrders = {}
4133 chandransh 11164 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11165 
          for _i178 in xrange(_size174):
11166 
            _key179 = iprot.readString();
11167 
            _val180 = iprot.readString();
11168 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11169 
          iprot.readMapEnd()
11170 
        else:
11171 
          iprot.skip(ftype)
1627 ankur.sing 11172 
      else:
11173 
        iprot.skip(ftype)
11174 
      iprot.readFieldEnd()
11175 
    iprot.readStructEnd()
11176 
 
11177 
  def write(self, oprot):
11178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11180 
      return
3064 chandransh 11181 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11182 
    if self.providerId is not None:
3064 chandransh 11183 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11184 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11185 
      oprot.writeFieldEnd()
3431 rajveer 11186 
    if self.undeliveredOrders is not None:
3064 chandransh 11187 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11188 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11189 
      for kiter181,viter182 in self.undeliveredOrders.items():
11190 
        oprot.writeString(kiter181)
11191 
        oprot.writeString(viter182)
3064 chandransh 11192 
      oprot.writeMapEnd()
11193 
      oprot.writeFieldEnd()
1627 ankur.sing 11194 
    oprot.writeFieldStop()
11195 
    oprot.writeStructEnd()
11196 
 
3431 rajveer 11197 
  def validate(self):
11198 
    return
11199 
 
11200 
 
1627 ankur.sing 11201 
  def __repr__(self):
11202 
    L = ['%s=%r' % (key, value)
11203 
      for key, value in self.__dict__.iteritems()]
11204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11205 
 
11206 
  def __eq__(self, other):
11207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11208 
 
11209 
  def __ne__(self, other):
11210 
    return not (self == other)
11211 
 
3064 chandransh 11212 
class updateNonDeliveryReason_result:
1627 ankur.sing 11213 
  """
11214 
  Attributes:
4581 phani.kuma 11215 
   - success
3064 chandransh 11216 
   - ex
1627 ankur.sing 11217 
  """
11218 
 
11219 
  thrift_spec = (
4581 phani.kuma 11220 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11222 
  )
11223 
 
4581 phani.kuma 11224 
  def __init__(self, success=None, ex=None,):
11225 
    self.success = success
3064 chandransh 11226 
    self.ex = ex
1627 ankur.sing 11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
4581 phani.kuma 11237 
      if fid == 0:
11238 
        if ftype == TType.LIST:
11239 
          self.success = []
11240 
          (_etype186, _size183) = iprot.readListBegin()
11241 
          for _i187 in xrange(_size183):
11242 
            _elem188 = Order()
11243 
            _elem188.read(iprot)
11244 
            self.success.append(_elem188)
11245 
          iprot.readListEnd()
11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      elif fid == 1:
3064 chandransh 11249 
        if ftype == TType.STRUCT:
11250 
          self.ex = TransactionServiceException()
11251 
          self.ex.read(iprot)
1627 ankur.sing 11252 
        else:
11253 
          iprot.skip(ftype)
11254 
      else:
11255 
        iprot.skip(ftype)
11256 
      iprot.readFieldEnd()
11257 
    iprot.readStructEnd()
11258 
 
11259 
  def write(self, oprot):
11260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11262 
      return
3064 chandransh 11263 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11264 
    if self.success is not None:
11265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11267 
      for iter189 in self.success:
11268 
        iter189.write(oprot)
11269 
      oprot.writeListEnd()
11270 
      oprot.writeFieldEnd()
3431 rajveer 11271 
    if self.ex is not None:
3064 chandransh 11272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11273 
      self.ex.write(oprot)
1627 ankur.sing 11274 
      oprot.writeFieldEnd()
11275 
    oprot.writeFieldStop()
11276 
    oprot.writeStructEnd()
11277 
 
3431 rajveer 11278 
  def validate(self):
11279 
    return
11280 
 
11281 
 
1627 ankur.sing 11282 
  def __repr__(self):
11283 
    L = ['%s=%r' % (key, value)
11284 
      for key, value in self.__dict__.iteritems()]
11285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11286 
 
11287 
  def __eq__(self, other):
11288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11289 
 
11290 
  def __ne__(self, other):
11291 
    return not (self == other)
11292 
 
3064 chandransh 11293 
class getUndeliveredOrders_args:
1886 ankur.sing 11294 
  """
11295 
  Attributes:
3064 chandransh 11296 
   - providerId
11297 
   - warehouseId
1886 ankur.sing 11298 
  """
1627 ankur.sing 11299 
 
1886 ankur.sing 11300 
  thrift_spec = (
11301 
    None, # 0
3064 chandransh 11302 
    (1, TType.I64, 'providerId', None, None, ), # 1
11303 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11304 
  )
11305 
 
3064 chandransh 11306 
  def __init__(self, providerId=None, warehouseId=None,):
11307 
    self.providerId = providerId
11308 
    self.warehouseId = warehouseId
1886 ankur.sing 11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
11319 
      if fid == 1:
11320 
        if ftype == TType.I64:
3064 chandransh 11321 
          self.providerId = iprot.readI64();
1886 ankur.sing 11322 
        else:
11323 
          iprot.skip(ftype)
3064 chandransh 11324 
      elif fid == 2:
11325 
        if ftype == TType.I64:
11326 
          self.warehouseId = iprot.readI64();
11327 
        else:
11328 
          iprot.skip(ftype)
1886 ankur.sing 11329 
      else:
11330 
        iprot.skip(ftype)
11331 
      iprot.readFieldEnd()
11332 
    iprot.readStructEnd()
11333 
 
11334 
  def write(self, oprot):
11335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11337 
      return
3064 chandransh 11338 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11339 
    if self.providerId is not None:
3064 chandransh 11340 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11341 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11342 
      oprot.writeFieldEnd()
3431 rajveer 11343 
    if self.warehouseId is not None:
3064 chandransh 11344 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11345 
      oprot.writeI64(self.warehouseId)
11346 
      oprot.writeFieldEnd()
1886 ankur.sing 11347 
    oprot.writeFieldStop()
11348 
    oprot.writeStructEnd()
11349 
 
3431 rajveer 11350 
  def validate(self):
11351 
    return
11352 
 
11353 
 
1886 ankur.sing 11354 
  def __repr__(self):
11355 
    L = ['%s=%r' % (key, value)
11356 
      for key, value in self.__dict__.iteritems()]
11357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11358 
 
11359 
  def __eq__(self, other):
11360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11361 
 
11362 
  def __ne__(self, other):
11363 
    return not (self == other)
11364 
 
3064 chandransh 11365 
class getUndeliveredOrders_result:
1886 ankur.sing 11366 
  """
11367 
  Attributes:
11368 
   - success
11369 
  """
11370 
 
11371 
  thrift_spec = (
11372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11373 
  )
11374 
 
11375 
  def __init__(self, success=None,):
11376 
    self.success = success
11377 
 
11378 
  def read(self, iprot):
11379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11381 
      return
11382 
    iprot.readStructBegin()
11383 
    while True:
11384 
      (fname, ftype, fid) = iprot.readFieldBegin()
11385 
      if ftype == TType.STOP:
11386 
        break
11387 
      if fid == 0:
11388 
        if ftype == TType.LIST:
11389 
          self.success = []
4581 phani.kuma 11390 
          (_etype193, _size190) = iprot.readListBegin()
11391 
          for _i194 in xrange(_size190):
11392 
            _elem195 = Order()
11393 
            _elem195.read(iprot)
11394 
            self.success.append(_elem195)
1886 ankur.sing 11395 
          iprot.readListEnd()
11396 
        else:
11397 
          iprot.skip(ftype)
11398 
      else:
11399 
        iprot.skip(ftype)
11400 
      iprot.readFieldEnd()
11401 
    iprot.readStructEnd()
11402 
 
11403 
  def write(self, oprot):
11404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11406 
      return
3064 chandransh 11407 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11408 
    if self.success is not None:
1886 ankur.sing 11409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11411 
      for iter196 in self.success:
11412 
        iter196.write(oprot)
1886 ankur.sing 11413 
      oprot.writeListEnd()
11414 
      oprot.writeFieldEnd()
11415 
    oprot.writeFieldStop()
11416 
    oprot.writeStructEnd()
11417 
 
3431 rajveer 11418 
  def validate(self):
11419 
    return
11420 
 
11421 
 
1886 ankur.sing 11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
2536 chandransh 11433 
class toggleDOAFlag_args:
11434 
  """
11435 
  Attributes:
11436 
   - orderId
11437 
  """
1886 ankur.sing 11438 
 
2536 chandransh 11439 
  thrift_spec = (
11440 
    None, # 0
11441 
    (1, TType.I64, 'orderId', None, None, ), # 1
11442 
  )
11443 
 
11444 
  def __init__(self, orderId=None,):
11445 
    self.orderId = orderId
11446 
 
11447 
  def read(self, iprot):
11448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11450 
      return
11451 
    iprot.readStructBegin()
11452 
    while True:
11453 
      (fname, ftype, fid) = iprot.readFieldBegin()
11454 
      if ftype == TType.STOP:
11455 
        break
11456 
      if fid == 1:
11457 
        if ftype == TType.I64:
11458 
          self.orderId = iprot.readI64();
11459 
        else:
11460 
          iprot.skip(ftype)
11461 
      else:
11462 
        iprot.skip(ftype)
11463 
      iprot.readFieldEnd()
11464 
    iprot.readStructEnd()
11465 
 
11466 
  def write(self, oprot):
11467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11469 
      return
11470 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11471 
    if self.orderId is not None:
2536 chandransh 11472 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11473 
      oprot.writeI64(self.orderId)
11474 
      oprot.writeFieldEnd()
11475 
    oprot.writeFieldStop()
11476 
    oprot.writeStructEnd()
11477 
 
3431 rajveer 11478 
  def validate(self):
11479 
    return
11480 
 
11481 
 
2536 chandransh 11482 
  def __repr__(self):
11483 
    L = ['%s=%r' % (key, value)
11484 
      for key, value in self.__dict__.iteritems()]
11485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11486 
 
11487 
  def __eq__(self, other):
11488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11489 
 
11490 
  def __ne__(self, other):
11491 
    return not (self == other)
11492 
 
11493 
class toggleDOAFlag_result:
11494 
  """
11495 
  Attributes:
11496 
   - success
11497 
   - ex
11498 
  """
11499 
 
11500 
  thrift_spec = (
11501 
    (0, TType.BOOL, 'success', None, None, ), # 0
11502 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11503 
  )
11504 
 
11505 
  def __init__(self, success=None, ex=None,):
11506 
    self.success = success
11507 
    self.ex = ex
11508 
 
11509 
  def read(self, iprot):
11510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11512 
      return
11513 
    iprot.readStructBegin()
11514 
    while True:
11515 
      (fname, ftype, fid) = iprot.readFieldBegin()
11516 
      if ftype == TType.STOP:
11517 
        break
11518 
      if fid == 0:
11519 
        if ftype == TType.BOOL:
11520 
          self.success = iprot.readBool();
11521 
        else:
11522 
          iprot.skip(ftype)
11523 
      elif fid == 1:
11524 
        if ftype == TType.STRUCT:
11525 
          self.ex = TransactionServiceException()
11526 
          self.ex.read(iprot)
11527 
        else:
11528 
          iprot.skip(ftype)
11529 
      else:
11530 
        iprot.skip(ftype)
11531 
      iprot.readFieldEnd()
11532 
    iprot.readStructEnd()
11533 
 
11534 
  def write(self, oprot):
11535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11537 
      return
11538 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11539 
    if self.success is not None:
2536 chandransh 11540 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11541 
      oprot.writeBool(self.success)
11542 
      oprot.writeFieldEnd()
3431 rajveer 11543 
    if self.ex is not None:
2536 chandransh 11544 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11545 
      self.ex.write(oprot)
11546 
      oprot.writeFieldEnd()
11547 
    oprot.writeFieldStop()
11548 
    oprot.writeStructEnd()
11549 
 
3431 rajveer 11550 
  def validate(self):
11551 
    return
11552 
 
11553 
 
2536 chandransh 11554 
  def __repr__(self):
11555 
    L = ['%s=%r' % (key, value)
11556 
      for key, value in self.__dict__.iteritems()]
11557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11558 
 
11559 
  def __eq__(self, other):
11560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11561 
 
11562 
  def __ne__(self, other):
11563 
    return not (self == other)
11564 
 
4454 rajveer 11565 
class markOrderDoaRequestReceived_args:
11566 
  """
11567 
  Attributes:
11568 
   - orderId
11569 
  """
11570 
 
11571 
  thrift_spec = (
11572 
    None, # 0
11573 
    (1, TType.I64, 'orderId', None, None, ), # 1
11574 
  )
11575 
 
11576 
  def __init__(self, orderId=None,):
11577 
    self.orderId = orderId
11578 
 
11579 
  def read(self, iprot):
11580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11582 
      return
11583 
    iprot.readStructBegin()
11584 
    while True:
11585 
      (fname, ftype, fid) = iprot.readFieldBegin()
11586 
      if ftype == TType.STOP:
11587 
        break
11588 
      if fid == 1:
11589 
        if ftype == TType.I64:
11590 
          self.orderId = iprot.readI64();
11591 
        else:
11592 
          iprot.skip(ftype)
11593 
      else:
11594 
        iprot.skip(ftype)
11595 
      iprot.readFieldEnd()
11596 
    iprot.readStructEnd()
11597 
 
11598 
  def write(self, oprot):
11599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11601 
      return
11602 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11603 
    if self.orderId is not None:
11604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11605 
      oprot.writeI64(self.orderId)
11606 
      oprot.writeFieldEnd()
11607 
    oprot.writeFieldStop()
11608 
    oprot.writeStructEnd()
11609 
 
11610 
  def validate(self):
11611 
    return
11612 
 
11613 
 
11614 
  def __repr__(self):
11615 
    L = ['%s=%r' % (key, value)
11616 
      for key, value in self.__dict__.iteritems()]
11617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11618 
 
11619 
  def __eq__(self, other):
11620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11621 
 
11622 
  def __ne__(self, other):
11623 
    return not (self == other)
11624 
 
11625 
class markOrderDoaRequestReceived_result:
11626 
  """
11627 
  Attributes:
11628 
   - success
11629 
   - ex
11630 
  """
11631 
 
11632 
  thrift_spec = (
11633 
    (0, TType.BOOL, 'success', None, None, ), # 0
11634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11635 
  )
11636 
 
11637 
  def __init__(self, success=None, ex=None,):
11638 
    self.success = success
11639 
    self.ex = ex
11640 
 
11641 
  def read(self, iprot):
11642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11644 
      return
11645 
    iprot.readStructBegin()
11646 
    while True:
11647 
      (fname, ftype, fid) = iprot.readFieldBegin()
11648 
      if ftype == TType.STOP:
11649 
        break
11650 
      if fid == 0:
11651 
        if ftype == TType.BOOL:
11652 
          self.success = iprot.readBool();
11653 
        else:
11654 
          iprot.skip(ftype)
11655 
      elif fid == 1:
11656 
        if ftype == TType.STRUCT:
11657 
          self.ex = TransactionServiceException()
11658 
          self.ex.read(iprot)
11659 
        else:
11660 
          iprot.skip(ftype)
11661 
      else:
11662 
        iprot.skip(ftype)
11663 
      iprot.readFieldEnd()
11664 
    iprot.readStructEnd()
11665 
 
11666 
  def write(self, oprot):
11667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11669 
      return
11670 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11671 
    if self.success is not None:
11672 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11673 
      oprot.writeBool(self.success)
11674 
      oprot.writeFieldEnd()
11675 
    if self.ex is not None:
11676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11677 
      self.ex.write(oprot)
11678 
      oprot.writeFieldEnd()
11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
11697 
class markOrderDoaRequestAuthorized_args:
11698 
  """
11699 
  Attributes:
11700 
   - orderId
11701 
   - isAuthorized
11702 
  """
11703 
 
11704 
  thrift_spec = (
11705 
    None, # 0
11706 
    (1, TType.I64, 'orderId', None, None, ), # 1
11707 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11708 
  )
11709 
 
11710 
  def __init__(self, orderId=None, isAuthorized=None,):
11711 
    self.orderId = orderId
11712 
    self.isAuthorized = isAuthorized
11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 1:
11724 
        if ftype == TType.I64:
11725 
          self.orderId = iprot.readI64();
11726 
        else:
11727 
          iprot.skip(ftype)
11728 
      elif fid == 2:
11729 
        if ftype == TType.BOOL:
11730 
          self.isAuthorized = iprot.readBool();
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      else:
11734 
        iprot.skip(ftype)
11735 
      iprot.readFieldEnd()
11736 
    iprot.readStructEnd()
11737 
 
11738 
  def write(self, oprot):
11739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11741 
      return
11742 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11743 
    if self.orderId is not None:
11744 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11745 
      oprot.writeI64(self.orderId)
11746 
      oprot.writeFieldEnd()
11747 
    if self.isAuthorized is not None:
11748 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11749 
      oprot.writeBool(self.isAuthorized)
11750 
      oprot.writeFieldEnd()
11751 
    oprot.writeFieldStop()
11752 
    oprot.writeStructEnd()
11753 
 
11754 
  def validate(self):
11755 
    return
11756 
 
11757 
 
11758 
  def __repr__(self):
11759 
    L = ['%s=%r' % (key, value)
11760 
      for key, value in self.__dict__.iteritems()]
11761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11762 
 
11763 
  def __eq__(self, other):
11764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11765 
 
11766 
  def __ne__(self, other):
11767 
    return not (self == other)
11768 
 
11769 
class markOrderDoaRequestAuthorized_result:
11770 
  """
11771 
  Attributes:
11772 
   - success
11773 
   - ex
11774 
  """
11775 
 
11776 
  thrift_spec = (
11777 
    (0, TType.BOOL, 'success', None, None, ), # 0
11778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11779 
  )
11780 
 
11781 
  def __init__(self, success=None, ex=None,):
11782 
    self.success = success
11783 
    self.ex = ex
11784 
 
11785 
  def read(self, iprot):
11786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11788 
      return
11789 
    iprot.readStructBegin()
11790 
    while True:
11791 
      (fname, ftype, fid) = iprot.readFieldBegin()
11792 
      if ftype == TType.STOP:
11793 
        break
11794 
      if fid == 0:
11795 
        if ftype == TType.BOOL:
11796 
          self.success = iprot.readBool();
11797 
        else:
11798 
          iprot.skip(ftype)
11799 
      elif fid == 1:
11800 
        if ftype == TType.STRUCT:
11801 
          self.ex = TransactionServiceException()
11802 
          self.ex.read(iprot)
11803 
        else:
11804 
          iprot.skip(ftype)
11805 
      else:
11806 
        iprot.skip(ftype)
11807 
      iprot.readFieldEnd()
11808 
    iprot.readStructEnd()
11809 
 
11810 
  def write(self, oprot):
11811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11813 
      return
11814 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11815 
    if self.success is not None:
11816 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11817 
      oprot.writeBool(self.success)
11818 
      oprot.writeFieldEnd()
11819 
    if self.ex is not None:
11820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11821 
      self.ex.write(oprot)
11822 
      oprot.writeFieldEnd()
11823 
    oprot.writeFieldStop()
11824 
    oprot.writeStructEnd()
11825 
 
11826 
  def validate(self):
11827 
    return
11828 
 
11829 
 
11830 
  def __repr__(self):
11831 
    L = ['%s=%r' % (key, value)
11832 
      for key, value in self.__dict__.iteritems()]
11833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11834 
 
11835 
  def __eq__(self, other):
11836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11837 
 
11838 
  def __ne__(self, other):
11839 
    return not (self == other)
11840 
 
4488 rajveer 11841 
class markOrderReturnRequestReceived_args:
11842 
  """
11843 
  Attributes:
11844 
   - orderId
11845 
  """
11846 
 
11847 
  thrift_spec = (
11848 
    None, # 0
11849 
    (1, TType.I64, 'orderId', None, None, ), # 1
11850 
  )
11851 
 
11852 
  def __init__(self, orderId=None,):
11853 
    self.orderId = orderId
11854 
 
11855 
  def read(self, iprot):
11856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11858 
      return
11859 
    iprot.readStructBegin()
11860 
    while True:
11861 
      (fname, ftype, fid) = iprot.readFieldBegin()
11862 
      if ftype == TType.STOP:
11863 
        break
11864 
      if fid == 1:
11865 
        if ftype == TType.I64:
11866 
          self.orderId = iprot.readI64();
11867 
        else:
11868 
          iprot.skip(ftype)
11869 
      else:
11870 
        iprot.skip(ftype)
11871 
      iprot.readFieldEnd()
11872 
    iprot.readStructEnd()
11873 
 
11874 
  def write(self, oprot):
11875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11877 
      return
11878 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11879 
    if self.orderId is not None:
11880 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11881 
      oprot.writeI64(self.orderId)
11882 
      oprot.writeFieldEnd()
11883 
    oprot.writeFieldStop()
11884 
    oprot.writeStructEnd()
11885 
 
11886 
  def validate(self):
11887 
    return
11888 
 
11889 
 
11890 
  def __repr__(self):
11891 
    L = ['%s=%r' % (key, value)
11892 
      for key, value in self.__dict__.iteritems()]
11893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11894 
 
11895 
  def __eq__(self, other):
11896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11897 
 
11898 
  def __ne__(self, other):
11899 
    return not (self == other)
11900 
 
11901 
class markOrderReturnRequestReceived_result:
11902 
  """
11903 
  Attributes:
11904 
   - success
11905 
   - ex
11906 
  """
11907 
 
11908 
  thrift_spec = (
11909 
    (0, TType.BOOL, 'success', None, None, ), # 0
11910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11911 
  )
11912 
 
11913 
  def __init__(self, success=None, ex=None,):
11914 
    self.success = success
11915 
    self.ex = ex
11916 
 
11917 
  def read(self, iprot):
11918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11920 
      return
11921 
    iprot.readStructBegin()
11922 
    while True:
11923 
      (fname, ftype, fid) = iprot.readFieldBegin()
11924 
      if ftype == TType.STOP:
11925 
        break
11926 
      if fid == 0:
11927 
        if ftype == TType.BOOL:
11928 
          self.success = iprot.readBool();
11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      elif fid == 1:
11932 
        if ftype == TType.STRUCT:
11933 
          self.ex = TransactionServiceException()
11934 
          self.ex.read(iprot)
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      else:
11938 
        iprot.skip(ftype)
11939 
      iprot.readFieldEnd()
11940 
    iprot.readStructEnd()
11941 
 
11942 
  def write(self, oprot):
11943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11945 
      return
11946 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11947 
    if self.success is not None:
11948 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11949 
      oprot.writeBool(self.success)
11950 
      oprot.writeFieldEnd()
11951 
    if self.ex is not None:
11952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11953 
      self.ex.write(oprot)
11954 
      oprot.writeFieldEnd()
11955 
    oprot.writeFieldStop()
11956 
    oprot.writeStructEnd()
11957 
 
11958 
  def validate(self):
11959 
    return
11960 
 
11961 
 
11962 
  def __repr__(self):
11963 
    L = ['%s=%r' % (key, value)
11964 
      for key, value in self.__dict__.iteritems()]
11965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11966 
 
11967 
  def __eq__(self, other):
11968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11969 
 
11970 
  def __ne__(self, other):
11971 
    return not (self == other)
11972 
 
11973 
class markOrderReturnRequestAuthorized_args:
11974 
  """
11975 
  Attributes:
11976 
   - orderId
11977 
   - isAuthorized
11978 
  """
11979 
 
11980 
  thrift_spec = (
11981 
    None, # 0
11982 
    (1, TType.I64, 'orderId', None, None, ), # 1
11983 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11984 
  )
11985 
 
11986 
  def __init__(self, orderId=None, isAuthorized=None,):
11987 
    self.orderId = orderId
11988 
    self.isAuthorized = isAuthorized
11989 
 
11990 
  def read(self, iprot):
11991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11993 
      return
11994 
    iprot.readStructBegin()
11995 
    while True:
11996 
      (fname, ftype, fid) = iprot.readFieldBegin()
11997 
      if ftype == TType.STOP:
11998 
        break
11999 
      if fid == 1:
12000 
        if ftype == TType.I64:
12001 
          self.orderId = iprot.readI64();
12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      elif fid == 2:
12005 
        if ftype == TType.BOOL:
12006 
          self.isAuthorized = iprot.readBool();
12007 
        else:
12008 
          iprot.skip(ftype)
12009 
      else:
12010 
        iprot.skip(ftype)
12011 
      iprot.readFieldEnd()
12012 
    iprot.readStructEnd()
12013 
 
12014 
  def write(self, oprot):
12015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12017 
      return
12018 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12019 
    if self.orderId is not None:
12020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12021 
      oprot.writeI64(self.orderId)
12022 
      oprot.writeFieldEnd()
12023 
    if self.isAuthorized is not None:
12024 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12025 
      oprot.writeBool(self.isAuthorized)
12026 
      oprot.writeFieldEnd()
12027 
    oprot.writeFieldStop()
12028 
    oprot.writeStructEnd()
12029 
 
12030 
  def validate(self):
12031 
    return
12032 
 
12033 
 
12034 
  def __repr__(self):
12035 
    L = ['%s=%r' % (key, value)
12036 
      for key, value in self.__dict__.iteritems()]
12037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12038 
 
12039 
  def __eq__(self, other):
12040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12041 
 
12042 
  def __ne__(self, other):
12043 
    return not (self == other)
12044 
 
12045 
class markOrderReturnRequestAuthorized_result:
12046 
  """
12047 
  Attributes:
12048 
   - success
12049 
   - ex
12050 
  """
12051 
 
12052 
  thrift_spec = (
12053 
    (0, TType.BOOL, 'success', None, None, ), # 0
12054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12055 
  )
12056 
 
12057 
  def __init__(self, success=None, ex=None,):
12058 
    self.success = success
12059 
    self.ex = ex
12060 
 
12061 
  def read(self, iprot):
12062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12064 
      return
12065 
    iprot.readStructBegin()
12066 
    while True:
12067 
      (fname, ftype, fid) = iprot.readFieldBegin()
12068 
      if ftype == TType.STOP:
12069 
        break
12070 
      if fid == 0:
12071 
        if ftype == TType.BOOL:
12072 
          self.success = iprot.readBool();
12073 
        else:
12074 
          iprot.skip(ftype)
12075 
      elif fid == 1:
12076 
        if ftype == TType.STRUCT:
12077 
          self.ex = TransactionServiceException()
12078 
          self.ex.read(iprot)
12079 
        else:
12080 
          iprot.skip(ftype)
12081 
      else:
12082 
        iprot.skip(ftype)
12083 
      iprot.readFieldEnd()
12084 
    iprot.readStructEnd()
12085 
 
12086 
  def write(self, oprot):
12087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12089 
      return
12090 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12091 
    if self.success is not None:
12092 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12093 
      oprot.writeBool(self.success)
12094 
      oprot.writeFieldEnd()
12095 
    if self.ex is not None:
12096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12097 
      self.ex.write(oprot)
12098 
      oprot.writeFieldEnd()
12099 
    oprot.writeFieldStop()
12100 
    oprot.writeStructEnd()
12101 
 
12102 
  def validate(self):
12103 
    return
12104 
 
12105 
 
12106 
  def __repr__(self):
12107 
    L = ['%s=%r' % (key, value)
12108 
      for key, value in self.__dict__.iteritems()]
12109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12110 
 
12111 
  def __eq__(self, other):
12112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12113 
 
12114 
  def __ne__(self, other):
12115 
    return not (self == other)
12116 
 
2536 chandransh 12117 
class requestPickupNumber_args:
12118 
  """
12119 
  Attributes:
12120 
   - orderId
4579 rajveer 12121 
   - providerId
2536 chandransh 12122 
  """
12123 
 
12124 
  thrift_spec = (
12125 
    None, # 0
12126 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12127 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12128 
  )
12129 
 
4579 rajveer 12130 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12131 
    self.orderId = orderId
4579 rajveer 12132 
    self.providerId = providerId
2536 chandransh 12133 
 
12134 
  def read(self, iprot):
12135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12137 
      return
12138 
    iprot.readStructBegin()
12139 
    while True:
12140 
      (fname, ftype, fid) = iprot.readFieldBegin()
12141 
      if ftype == TType.STOP:
12142 
        break
12143 
      if fid == 1:
12144 
        if ftype == TType.I64:
12145 
          self.orderId = iprot.readI64();
12146 
        else:
12147 
          iprot.skip(ftype)
4579 rajveer 12148 
      elif fid == 2:
12149 
        if ftype == TType.I64:
12150 
          self.providerId = iprot.readI64();
12151 
        else:
12152 
          iprot.skip(ftype)
2536 chandransh 12153 
      else:
12154 
        iprot.skip(ftype)
12155 
      iprot.readFieldEnd()
12156 
    iprot.readStructEnd()
12157 
 
12158 
  def write(self, oprot):
12159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12161 
      return
12162 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12163 
    if self.orderId is not None:
2536 chandransh 12164 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12165 
      oprot.writeI64(self.orderId)
12166 
      oprot.writeFieldEnd()
4579 rajveer 12167 
    if self.providerId is not None:
12168 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12169 
      oprot.writeI64(self.providerId)
12170 
      oprot.writeFieldEnd()
2536 chandransh 12171 
    oprot.writeFieldStop()
12172 
    oprot.writeStructEnd()
12173 
 
3431 rajveer 12174 
  def validate(self):
12175 
    return
12176 
 
12177 
 
2536 chandransh 12178 
  def __repr__(self):
12179 
    L = ['%s=%r' % (key, value)
12180 
      for key, value in self.__dict__.iteritems()]
12181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12182 
 
12183 
  def __eq__(self, other):
12184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12185 
 
12186 
  def __ne__(self, other):
12187 
    return not (self == other)
12188 
 
12189 
class requestPickupNumber_result:
12190 
  """
12191 
  Attributes:
12192 
   - success
12193 
   - ex
12194 
  """
12195 
 
12196 
  thrift_spec = (
12197 
    (0, TType.BOOL, 'success', None, None, ), # 0
12198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12199 
  )
12200 
 
12201 
  def __init__(self, success=None, ex=None,):
12202 
    self.success = success
12203 
    self.ex = ex
12204 
 
12205 
  def read(self, iprot):
12206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12208 
      return
12209 
    iprot.readStructBegin()
12210 
    while True:
12211 
      (fname, ftype, fid) = iprot.readFieldBegin()
12212 
      if ftype == TType.STOP:
12213 
        break
12214 
      if fid == 0:
12215 
        if ftype == TType.BOOL:
12216 
          self.success = iprot.readBool();
12217 
        else:
12218 
          iprot.skip(ftype)
12219 
      elif fid == 1:
12220 
        if ftype == TType.STRUCT:
12221 
          self.ex = TransactionServiceException()
12222 
          self.ex.read(iprot)
12223 
        else:
12224 
          iprot.skip(ftype)
12225 
      else:
12226 
        iprot.skip(ftype)
12227 
      iprot.readFieldEnd()
12228 
    iprot.readStructEnd()
12229 
 
12230 
  def write(self, oprot):
12231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12233 
      return
12234 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12235 
    if self.success is not None:
2536 chandransh 12236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12237 
      oprot.writeBool(self.success)
12238 
      oprot.writeFieldEnd()
3431 rajveer 12239 
    if self.ex is not None:
2536 chandransh 12240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12241 
      self.ex.write(oprot)
12242 
      oprot.writeFieldEnd()
12243 
    oprot.writeFieldStop()
12244 
    oprot.writeStructEnd()
12245 
 
3431 rajveer 12246 
  def validate(self):
12247 
    return
12248 
 
12249 
 
2536 chandransh 12250 
  def __repr__(self):
12251 
    L = ['%s=%r' % (key, value)
12252 
      for key, value in self.__dict__.iteritems()]
12253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12254 
 
12255 
  def __eq__(self, other):
12256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12257 
 
12258 
  def __ne__(self, other):
12259 
    return not (self == other)
12260 
 
12261 
class authorizePickup_args:
12262 
  """
12263 
  Attributes:
12264 
   - orderId
12265 
   - pickupNumber
12266 
  """
12267 
 
12268 
  thrift_spec = (
12269 
    None, # 0
12270 
    (1, TType.I64, 'orderId', None, None, ), # 1
12271 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
12272 
  )
12273 
 
12274 
  def __init__(self, orderId=None, pickupNumber=None,):
12275 
    self.orderId = orderId
12276 
    self.pickupNumber = pickupNumber
12277 
 
12278 
  def read(self, iprot):
12279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12281 
      return
12282 
    iprot.readStructBegin()
12283 
    while True:
12284 
      (fname, ftype, fid) = iprot.readFieldBegin()
12285 
      if ftype == TType.STOP:
12286 
        break
12287 
      if fid == 1:
12288 
        if ftype == TType.I64:
12289 
          self.orderId = iprot.readI64();
12290 
        else:
12291 
          iprot.skip(ftype)
12292 
      elif fid == 2:
12293 
        if ftype == TType.STRING:
12294 
          self.pickupNumber = iprot.readString();
12295 
        else:
12296 
          iprot.skip(ftype)
12297 
      else:
12298 
        iprot.skip(ftype)
12299 
      iprot.readFieldEnd()
12300 
    iprot.readStructEnd()
12301 
 
12302 
  def write(self, oprot):
12303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12305 
      return
12306 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12307 
    if self.orderId is not None:
2536 chandransh 12308 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12309 
      oprot.writeI64(self.orderId)
12310 
      oprot.writeFieldEnd()
3431 rajveer 12311 
    if self.pickupNumber is not None:
2536 chandransh 12312 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12313 
      oprot.writeString(self.pickupNumber)
12314 
      oprot.writeFieldEnd()
12315 
    oprot.writeFieldStop()
12316 
    oprot.writeStructEnd()
12317 
 
3431 rajveer 12318 
  def validate(self):
12319 
    return
12320 
 
12321 
 
2536 chandransh 12322 
  def __repr__(self):
12323 
    L = ['%s=%r' % (key, value)
12324 
      for key, value in self.__dict__.iteritems()]
12325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12326 
 
12327 
  def __eq__(self, other):
12328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12329 
 
12330 
  def __ne__(self, other):
12331 
    return not (self == other)
12332 
 
12333 
class authorizePickup_result:
12334 
  """
12335 
  Attributes:
12336 
   - success
12337 
   - ex
12338 
  """
12339 
 
12340 
  thrift_spec = (
12341 
    (0, TType.BOOL, 'success', None, None, ), # 0
12342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12343 
  )
12344 
 
12345 
  def __init__(self, success=None, ex=None,):
12346 
    self.success = success
12347 
    self.ex = ex
12348 
 
12349 
  def read(self, iprot):
12350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12352 
      return
12353 
    iprot.readStructBegin()
12354 
    while True:
12355 
      (fname, ftype, fid) = iprot.readFieldBegin()
12356 
      if ftype == TType.STOP:
12357 
        break
12358 
      if fid == 0:
12359 
        if ftype == TType.BOOL:
12360 
          self.success = iprot.readBool();
12361 
        else:
12362 
          iprot.skip(ftype)
12363 
      elif fid == 1:
12364 
        if ftype == TType.STRUCT:
12365 
          self.ex = TransactionServiceException()
12366 
          self.ex.read(iprot)
12367 
        else:
12368 
          iprot.skip(ftype)
12369 
      else:
12370 
        iprot.skip(ftype)
12371 
      iprot.readFieldEnd()
12372 
    iprot.readStructEnd()
12373 
 
12374 
  def write(self, oprot):
12375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12377 
      return
12378 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12379 
    if self.success is not None:
2536 chandransh 12380 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12381 
      oprot.writeBool(self.success)
12382 
      oprot.writeFieldEnd()
3431 rajveer 12383 
    if self.ex is not None:
2536 chandransh 12384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12385 
      self.ex.write(oprot)
12386 
      oprot.writeFieldEnd()
12387 
    oprot.writeFieldStop()
12388 
    oprot.writeStructEnd()
12389 
 
3431 rajveer 12390 
  def validate(self):
12391 
    return
12392 
 
12393 
 
2536 chandransh 12394 
  def __repr__(self):
12395 
    L = ['%s=%r' % (key, value)
12396 
      for key, value in self.__dict__.iteritems()]
12397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12398 
 
12399 
  def __eq__(self, other):
12400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12401 
 
12402 
  def __ne__(self, other):
12403 
    return not (self == other)
12404 
 
2764 chandransh 12405 
class markDoasAsPickedUp_args:
12406 
  """
12407 
  Attributes:
12408 
   - providerId
12409 
   - pickupDetails
12410 
  """
12411 
 
12412 
  thrift_spec = (
12413 
    None, # 0
12414 
    (1, TType.I64, 'providerId', None, None, ), # 1
12415 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12416 
  )
12417 
 
12418 
  def __init__(self, providerId=None, pickupDetails=None,):
12419 
    self.providerId = providerId
12420 
    self.pickupDetails = pickupDetails
12421 
 
12422 
  def read(self, iprot):
12423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12425 
      return
12426 
    iprot.readStructBegin()
12427 
    while True:
12428 
      (fname, ftype, fid) = iprot.readFieldBegin()
12429 
      if ftype == TType.STOP:
12430 
        break
12431 
      if fid == 1:
12432 
        if ftype == TType.I64:
12433 
          self.providerId = iprot.readI64();
12434 
        else:
12435 
          iprot.skip(ftype)
12436 
      elif fid == 2:
12437 
        if ftype == TType.MAP:
12438 
          self.pickupDetails = {}
4581 phani.kuma 12439 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12440 
          for _i201 in xrange(_size197):
12441 
            _key202 = iprot.readString();
12442 
            _val203 = iprot.readString();
12443 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12444 
          iprot.readMapEnd()
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
12456 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12457 
    if self.providerId is not None:
2764 chandransh 12458 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12459 
      oprot.writeI64(self.providerId)
12460 
      oprot.writeFieldEnd()
3431 rajveer 12461 
    if self.pickupDetails is not None:
2764 chandransh 12462 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12463 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12464 
      for kiter204,viter205 in self.pickupDetails.items():
12465 
        oprot.writeString(kiter204)
12466 
        oprot.writeString(viter205)
2764 chandransh 12467 
      oprot.writeMapEnd()
12468 
      oprot.writeFieldEnd()
12469 
    oprot.writeFieldStop()
12470 
    oprot.writeStructEnd()
12471 
 
3431 rajveer 12472 
  def validate(self):
12473 
    return
12474 
 
12475 
 
2764 chandransh 12476 
  def __repr__(self):
12477 
    L = ['%s=%r' % (key, value)
12478 
      for key, value in self.__dict__.iteritems()]
12479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12480 
 
12481 
  def __eq__(self, other):
12482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12483 
 
12484 
  def __ne__(self, other):
12485 
    return not (self == other)
12486 
 
12487 
class markDoasAsPickedUp_result:
12488 
  """
12489 
  Attributes:
12490 
   - success
12491 
  """
12492 
 
12493 
  thrift_spec = (
12494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12495 
  )
12496 
 
12497 
  def __init__(self, success=None,):
12498 
    self.success = success
12499 
 
12500 
  def read(self, iprot):
12501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12503 
      return
12504 
    iprot.readStructBegin()
12505 
    while True:
12506 
      (fname, ftype, fid) = iprot.readFieldBegin()
12507 
      if ftype == TType.STOP:
12508 
        break
12509 
      if fid == 0:
12510 
        if ftype == TType.LIST:
12511 
          self.success = []
4581 phani.kuma 12512 
          (_etype209, _size206) = iprot.readListBegin()
12513 
          for _i210 in xrange(_size206):
12514 
            _elem211 = Order()
12515 
            _elem211.read(iprot)
12516 
            self.success.append(_elem211)
2764 chandransh 12517 
          iprot.readListEnd()
12518 
        else:
12519 
          iprot.skip(ftype)
12520 
      else:
12521 
        iprot.skip(ftype)
12522 
      iprot.readFieldEnd()
12523 
    iprot.readStructEnd()
12524 
 
12525 
  def write(self, oprot):
12526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12528 
      return
12529 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12530 
    if self.success is not None:
2764 chandransh 12531 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12532 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12533 
      for iter212 in self.success:
12534 
        iter212.write(oprot)
2764 chandransh 12535 
      oprot.writeListEnd()
12536 
      oprot.writeFieldEnd()
12537 
    oprot.writeFieldStop()
12538 
    oprot.writeStructEnd()
12539 
 
3431 rajveer 12540 
  def validate(self):
12541 
    return
12542 
 
12543 
 
2764 chandransh 12544 
  def __repr__(self):
12545 
    L = ['%s=%r' % (key, value)
12546 
      for key, value in self.__dict__.iteritems()]
12547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12548 
 
12549 
  def __eq__(self, other):
12550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12551 
 
12552 
  def __ne__(self, other):
12553 
    return not (self == other)
12554 
 
2616 chandransh 12555 
class receiveReturn_args:
2591 chandransh 12556 
  """
12557 
  Attributes:
12558 
   - orderId
4479 rajveer 12559 
   - receiveCondition
2591 chandransh 12560 
  """
2536 chandransh 12561 
 
2591 chandransh 12562 
  thrift_spec = (
12563 
    None, # 0
12564 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12565 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12566 
  )
12567 
 
4479 rajveer 12568 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12569 
    self.orderId = orderId
4479 rajveer 12570 
    self.receiveCondition = receiveCondition
2591 chandransh 12571 
 
12572 
  def read(self, iprot):
12573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12575 
      return
12576 
    iprot.readStructBegin()
12577 
    while True:
12578 
      (fname, ftype, fid) = iprot.readFieldBegin()
12579 
      if ftype == TType.STOP:
12580 
        break
12581 
      if fid == 1:
12582 
        if ftype == TType.I64:
12583 
          self.orderId = iprot.readI64();
12584 
        else:
12585 
          iprot.skip(ftype)
4479 rajveer 12586 
      elif fid == 2:
12587 
        if ftype == TType.I64:
12588 
          self.receiveCondition = iprot.readI64();
12589 
        else:
12590 
          iprot.skip(ftype)
2591 chandransh 12591 
      else:
12592 
        iprot.skip(ftype)
12593 
      iprot.readFieldEnd()
12594 
    iprot.readStructEnd()
12595 
 
12596 
  def write(self, oprot):
12597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12599 
      return
2616 chandransh 12600 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12601 
    if self.orderId is not None:
2591 chandransh 12602 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12603 
      oprot.writeI64(self.orderId)
12604 
      oprot.writeFieldEnd()
4479 rajveer 12605 
    if self.receiveCondition is not None:
12606 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12607 
      oprot.writeI64(self.receiveCondition)
12608 
      oprot.writeFieldEnd()
2591 chandransh 12609 
    oprot.writeFieldStop()
12610 
    oprot.writeStructEnd()
12611 
 
3431 rajveer 12612 
  def validate(self):
12613 
    return
12614 
 
12615 
 
2591 chandransh 12616 
  def __repr__(self):
12617 
    L = ['%s=%r' % (key, value)
12618 
      for key, value in self.__dict__.iteritems()]
12619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12620 
 
12621 
  def __eq__(self, other):
12622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12623 
 
12624 
  def __ne__(self, other):
12625 
    return not (self == other)
12626 
 
2616 chandransh 12627 
class receiveReturn_result:
2591 chandransh 12628 
  """
12629 
  Attributes:
12630 
   - success
12631 
   - ex
12632 
  """
12633 
 
12634 
  thrift_spec = (
12635 
    (0, TType.BOOL, 'success', None, None, ), # 0
12636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12637 
  )
12638 
 
12639 
  def __init__(self, success=None, ex=None,):
12640 
    self.success = success
12641 
    self.ex = ex
12642 
 
12643 
  def read(self, iprot):
12644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12646 
      return
12647 
    iprot.readStructBegin()
12648 
    while True:
12649 
      (fname, ftype, fid) = iprot.readFieldBegin()
12650 
      if ftype == TType.STOP:
12651 
        break
12652 
      if fid == 0:
12653 
        if ftype == TType.BOOL:
12654 
          self.success = iprot.readBool();
12655 
        else:
12656 
          iprot.skip(ftype)
12657 
      elif fid == 1:
12658 
        if ftype == TType.STRUCT:
12659 
          self.ex = TransactionServiceException()
12660 
          self.ex.read(iprot)
12661 
        else:
12662 
          iprot.skip(ftype)
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
2616 chandransh 12672 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12673 
    if self.success is not None:
2591 chandransh 12674 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12675 
      oprot.writeBool(self.success)
12676 
      oprot.writeFieldEnd()
3431 rajveer 12677 
    if self.ex is not None:
2591 chandransh 12678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12679 
      self.ex.write(oprot)
12680 
      oprot.writeFieldEnd()
12681 
    oprot.writeFieldStop()
12682 
    oprot.writeStructEnd()
12683 
 
3431 rajveer 12684 
  def validate(self):
12685 
    return
12686 
 
12687 
 
2591 chandransh 12688 
  def __repr__(self):
12689 
    L = ['%s=%r' % (key, value)
12690 
      for key, value in self.__dict__.iteritems()]
12691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12692 
 
12693 
  def __eq__(self, other):
12694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12695 
 
12696 
  def __ne__(self, other):
12697 
    return not (self == other)
12698 
 
12699 
class validateDoa_args:
12700 
  """
12701 
  Attributes:
12702 
   - orderId
12703 
   - isValid
12704 
  """
12705 
 
12706 
  thrift_spec = (
12707 
    None, # 0
12708 
    (1, TType.I64, 'orderId', None, None, ), # 1
12709 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12710 
  )
12711 
 
12712 
  def __init__(self, orderId=None, isValid=None,):
12713 
    self.orderId = orderId
12714 
    self.isValid = isValid
12715 
 
12716 
  def read(self, iprot):
12717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12719 
      return
12720 
    iprot.readStructBegin()
12721 
    while True:
12722 
      (fname, ftype, fid) = iprot.readFieldBegin()
12723 
      if ftype == TType.STOP:
12724 
        break
12725 
      if fid == 1:
12726 
        if ftype == TType.I64:
12727 
          self.orderId = iprot.readI64();
12728 
        else:
12729 
          iprot.skip(ftype)
12730 
      elif fid == 2:
12731 
        if ftype == TType.BOOL:
12732 
          self.isValid = iprot.readBool();
12733 
        else:
12734 
          iprot.skip(ftype)
12735 
      else:
12736 
        iprot.skip(ftype)
12737 
      iprot.readFieldEnd()
12738 
    iprot.readStructEnd()
12739 
 
12740 
  def write(self, oprot):
12741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12743 
      return
12744 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12745 
    if self.orderId is not None:
2591 chandransh 12746 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12747 
      oprot.writeI64(self.orderId)
12748 
      oprot.writeFieldEnd()
3431 rajveer 12749 
    if self.isValid is not None:
2591 chandransh 12750 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12751 
      oprot.writeBool(self.isValid)
12752 
      oprot.writeFieldEnd()
12753 
    oprot.writeFieldStop()
12754 
    oprot.writeStructEnd()
12755 
 
3431 rajveer 12756 
  def validate(self):
12757 
    return
12758 
 
12759 
 
2591 chandransh 12760 
  def __repr__(self):
12761 
    L = ['%s=%r' % (key, value)
12762 
      for key, value in self.__dict__.iteritems()]
12763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12764 
 
12765 
  def __eq__(self, other):
12766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12767 
 
12768 
  def __ne__(self, other):
12769 
    return not (self == other)
12770 
 
12771 
class validateDoa_result:
12772 
  """
12773 
  Attributes:
12774 
   - success
12775 
   - ex
12776 
  """
12777 
 
12778 
  thrift_spec = (
12779 
    (0, TType.BOOL, 'success', None, None, ), # 0
12780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12781 
  )
12782 
 
12783 
  def __init__(self, success=None, ex=None,):
12784 
    self.success = success
12785 
    self.ex = ex
12786 
 
12787 
  def read(self, iprot):
12788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12790 
      return
12791 
    iprot.readStructBegin()
12792 
    while True:
12793 
      (fname, ftype, fid) = iprot.readFieldBegin()
12794 
      if ftype == TType.STOP:
12795 
        break
12796 
      if fid == 0:
12797 
        if ftype == TType.BOOL:
12798 
          self.success = iprot.readBool();
12799 
        else:
12800 
          iprot.skip(ftype)
12801 
      elif fid == 1:
12802 
        if ftype == TType.STRUCT:
12803 
          self.ex = TransactionServiceException()
12804 
          self.ex.read(iprot)
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      else:
12808 
        iprot.skip(ftype)
12809 
      iprot.readFieldEnd()
12810 
    iprot.readStructEnd()
12811 
 
12812 
  def write(self, oprot):
12813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12815 
      return
12816 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12817 
    if self.success is not None:
2591 chandransh 12818 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12819 
      oprot.writeBool(self.success)
12820 
      oprot.writeFieldEnd()
3431 rajveer 12821 
    if self.ex is not None:
2591 chandransh 12822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12823 
      self.ex.write(oprot)
12824 
      oprot.writeFieldEnd()
12825 
    oprot.writeFieldStop()
12826 
    oprot.writeStructEnd()
12827 
 
3431 rajveer 12828 
  def validate(self):
12829 
    return
12830 
 
12831 
 
2591 chandransh 12832 
  def __repr__(self):
12833 
    L = ['%s=%r' % (key, value)
12834 
      for key, value in self.__dict__.iteritems()]
12835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12836 
 
12837 
  def __eq__(self, other):
12838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12839 
 
12840 
  def __ne__(self, other):
12841 
    return not (self == other)
12842 
 
4495 rajveer 12843 
class validateReturnProduct_args:
12844 
  """
12845 
  Attributes:
12846 
   - orderId
12847 
   - isUsable
12848 
  """
12849 
 
12850 
  thrift_spec = (
12851 
    None, # 0
12852 
    (1, TType.I64, 'orderId', None, None, ), # 1
12853 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12854 
  )
12855 
 
12856 
  def __init__(self, orderId=None, isUsable=None,):
12857 
    self.orderId = orderId
12858 
    self.isUsable = isUsable
12859 
 
12860 
  def read(self, iprot):
12861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12863 
      return
12864 
    iprot.readStructBegin()
12865 
    while True:
12866 
      (fname, ftype, fid) = iprot.readFieldBegin()
12867 
      if ftype == TType.STOP:
12868 
        break
12869 
      if fid == 1:
12870 
        if ftype == TType.I64:
12871 
          self.orderId = iprot.readI64();
12872 
        else:
12873 
          iprot.skip(ftype)
12874 
      elif fid == 2:
12875 
        if ftype == TType.BOOL:
12876 
          self.isUsable = iprot.readBool();
12877 
        else:
12878 
          iprot.skip(ftype)
12879 
      else:
12880 
        iprot.skip(ftype)
12881 
      iprot.readFieldEnd()
12882 
    iprot.readStructEnd()
12883 
 
12884 
  def write(self, oprot):
12885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12887 
      return
12888 
    oprot.writeStructBegin('validateReturnProduct_args')
12889 
    if self.orderId is not None:
12890 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12891 
      oprot.writeI64(self.orderId)
12892 
      oprot.writeFieldEnd()
12893 
    if self.isUsable is not None:
12894 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12895 
      oprot.writeBool(self.isUsable)
12896 
      oprot.writeFieldEnd()
12897 
    oprot.writeFieldStop()
12898 
    oprot.writeStructEnd()
12899 
 
12900 
  def validate(self):
12901 
    return
12902 
 
12903 
 
12904 
  def __repr__(self):
12905 
    L = ['%s=%r' % (key, value)
12906 
      for key, value in self.__dict__.iteritems()]
12907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12908 
 
12909 
  def __eq__(self, other):
12910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12911 
 
12912 
  def __ne__(self, other):
12913 
    return not (self == other)
12914 
 
12915 
class validateReturnProduct_result:
12916 
  """
12917 
  Attributes:
12918 
   - success
12919 
   - ex
12920 
  """
12921 
 
12922 
  thrift_spec = (
12923 
    (0, TType.BOOL, 'success', None, None, ), # 0
12924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12925 
  )
12926 
 
12927 
  def __init__(self, success=None, ex=None,):
12928 
    self.success = success
12929 
    self.ex = ex
12930 
 
12931 
  def read(self, iprot):
12932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12934 
      return
12935 
    iprot.readStructBegin()
12936 
    while True:
12937 
      (fname, ftype, fid) = iprot.readFieldBegin()
12938 
      if ftype == TType.STOP:
12939 
        break
12940 
      if fid == 0:
12941 
        if ftype == TType.BOOL:
12942 
          self.success = iprot.readBool();
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      elif fid == 1:
12946 
        if ftype == TType.STRUCT:
12947 
          self.ex = TransactionServiceException()
12948 
          self.ex.read(iprot)
12949 
        else:
12950 
          iprot.skip(ftype)
12951 
      else:
12952 
        iprot.skip(ftype)
12953 
      iprot.readFieldEnd()
12954 
    iprot.readStructEnd()
12955 
 
12956 
  def write(self, oprot):
12957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12959 
      return
12960 
    oprot.writeStructBegin('validateReturnProduct_result')
12961 
    if self.success is not None:
12962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12963 
      oprot.writeBool(self.success)
12964 
      oprot.writeFieldEnd()
12965 
    if self.ex is not None:
12966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12967 
      self.ex.write(oprot)
12968 
      oprot.writeFieldEnd()
12969 
    oprot.writeFieldStop()
12970 
    oprot.writeStructEnd()
12971 
 
12972 
  def validate(self):
12973 
    return
12974 
 
12975 
 
12976 
  def __repr__(self):
12977 
    L = ['%s=%r' % (key, value)
12978 
      for key, value in self.__dict__.iteritems()]
12979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12980 
 
12981 
  def __eq__(self, other):
12982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12983 
 
12984 
  def __ne__(self, other):
12985 
    return not (self == other)
12986 
 
2616 chandransh 12987 
class reshipOrder_args:
12988 
  """
12989 
  Attributes:
12990 
   - orderId
12991 
  """
2591 chandransh 12992 
 
2616 chandransh 12993 
  thrift_spec = (
12994 
    None, # 0
12995 
    (1, TType.I64, 'orderId', None, None, ), # 1
12996 
  )
12997 
 
12998 
  def __init__(self, orderId=None,):
12999 
    self.orderId = orderId
13000 
 
13001 
  def read(self, iprot):
13002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13004 
      return
13005 
    iprot.readStructBegin()
13006 
    while True:
13007 
      (fname, ftype, fid) = iprot.readFieldBegin()
13008 
      if ftype == TType.STOP:
13009 
        break
13010 
      if fid == 1:
13011 
        if ftype == TType.I64:
13012 
          self.orderId = iprot.readI64();
13013 
        else:
13014 
          iprot.skip(ftype)
13015 
      else:
13016 
        iprot.skip(ftype)
13017 
      iprot.readFieldEnd()
13018 
    iprot.readStructEnd()
13019 
 
13020 
  def write(self, oprot):
13021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13023 
      return
13024 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13025 
    if self.orderId is not None:
2616 chandransh 13026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13027 
      oprot.writeI64(self.orderId)
13028 
      oprot.writeFieldEnd()
13029 
    oprot.writeFieldStop()
13030 
    oprot.writeStructEnd()
13031 
 
3431 rajveer 13032 
  def validate(self):
13033 
    return
13034 
 
13035 
 
2616 chandransh 13036 
  def __repr__(self):
13037 
    L = ['%s=%r' % (key, value)
13038 
      for key, value in self.__dict__.iteritems()]
13039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13040 
 
13041 
  def __eq__(self, other):
13042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13043 
 
13044 
  def __ne__(self, other):
13045 
    return not (self == other)
13046 
 
13047 
class reshipOrder_result:
13048 
  """
13049 
  Attributes:
13050 
   - success
13051 
   - ex
13052 
  """
13053 
 
13054 
  thrift_spec = (
13055 
    (0, TType.I64, 'success', None, None, ), # 0
13056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13057 
  )
13058 
 
13059 
  def __init__(self, success=None, ex=None,):
13060 
    self.success = success
13061 
    self.ex = ex
13062 
 
13063 
  def read(self, iprot):
13064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13066 
      return
13067 
    iprot.readStructBegin()
13068 
    while True:
13069 
      (fname, ftype, fid) = iprot.readFieldBegin()
13070 
      if ftype == TType.STOP:
13071 
        break
13072 
      if fid == 0:
13073 
        if ftype == TType.I64:
13074 
          self.success = iprot.readI64();
13075 
        else:
13076 
          iprot.skip(ftype)
13077 
      elif fid == 1:
13078 
        if ftype == TType.STRUCT:
13079 
          self.ex = TransactionServiceException()
13080 
          self.ex.read(iprot)
13081 
        else:
13082 
          iprot.skip(ftype)
13083 
      else:
13084 
        iprot.skip(ftype)
13085 
      iprot.readFieldEnd()
13086 
    iprot.readStructEnd()
13087 
 
13088 
  def write(self, oprot):
13089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13091 
      return
13092 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13093 
    if self.success is not None:
2616 chandransh 13094 
      oprot.writeFieldBegin('success', TType.I64, 0)
13095 
      oprot.writeI64(self.success)
13096 
      oprot.writeFieldEnd()
3431 rajveer 13097 
    if self.ex is not None:
2616 chandransh 13098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13099 
      self.ex.write(oprot)
13100 
      oprot.writeFieldEnd()
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
3431 rajveer 13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
2616 chandransh 13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
13119 
class refundOrder_args:
13120 
  """
13121 
  Attributes:
13122 
   - orderId
3226 chandransh 13123 
   - refundedBy
13124 
   - reason
2616 chandransh 13125 
  """
13126 
 
13127 
  thrift_spec = (
13128 
    None, # 0
13129 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13130 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13131 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13132 
  )
13133 
 
3226 chandransh 13134 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13135 
    self.orderId = orderId
3226 chandransh 13136 
    self.refundedBy = refundedBy
13137 
    self.reason = reason
2616 chandransh 13138 
 
13139 
  def read(self, iprot):
13140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13142 
      return
13143 
    iprot.readStructBegin()
13144 
    while True:
13145 
      (fname, ftype, fid) = iprot.readFieldBegin()
13146 
      if ftype == TType.STOP:
13147 
        break
13148 
      if fid == 1:
13149 
        if ftype == TType.I64:
13150 
          self.orderId = iprot.readI64();
13151 
        else:
13152 
          iprot.skip(ftype)
3226 chandransh 13153 
      elif fid == 2:
13154 
        if ftype == TType.STRING:
13155 
          self.refundedBy = iprot.readString();
13156 
        else:
13157 
          iprot.skip(ftype)
13158 
      elif fid == 3:
13159 
        if ftype == TType.STRING:
13160 
          self.reason = iprot.readString();
13161 
        else:
13162 
          iprot.skip(ftype)
2616 chandransh 13163 
      else:
13164 
        iprot.skip(ftype)
13165 
      iprot.readFieldEnd()
13166 
    iprot.readStructEnd()
13167 
 
13168 
  def write(self, oprot):
13169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13171 
      return
13172 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13173 
    if self.orderId is not None:
2616 chandransh 13174 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13175 
      oprot.writeI64(self.orderId)
13176 
      oprot.writeFieldEnd()
3431 rajveer 13177 
    if self.refundedBy is not None:
3226 chandransh 13178 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13179 
      oprot.writeString(self.refundedBy)
13180 
      oprot.writeFieldEnd()
3431 rajveer 13181 
    if self.reason is not None:
3226 chandransh 13182 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13183 
      oprot.writeString(self.reason)
13184 
      oprot.writeFieldEnd()
2616 chandransh 13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
3431 rajveer 13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
2616 chandransh 13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
13203 
class refundOrder_result:
13204 
  """
13205 
  Attributes:
13206 
   - success
13207 
   - ex
13208 
  """
13209 
 
13210 
  thrift_spec = (
13211 
    (0, TType.BOOL, 'success', None, None, ), # 0
13212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13213 
  )
13214 
 
13215 
  def __init__(self, success=None, ex=None,):
13216 
    self.success = success
13217 
    self.ex = ex
13218 
 
13219 
  def read(self, iprot):
13220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13222 
      return
13223 
    iprot.readStructBegin()
13224 
    while True:
13225 
      (fname, ftype, fid) = iprot.readFieldBegin()
13226 
      if ftype == TType.STOP:
13227 
        break
13228 
      if fid == 0:
13229 
        if ftype == TType.BOOL:
13230 
          self.success = iprot.readBool();
13231 
        else:
13232 
          iprot.skip(ftype)
13233 
      elif fid == 1:
13234 
        if ftype == TType.STRUCT:
13235 
          self.ex = TransactionServiceException()
13236 
          self.ex.read(iprot)
13237 
        else:
13238 
          iprot.skip(ftype)
13239 
      else:
13240 
        iprot.skip(ftype)
13241 
      iprot.readFieldEnd()
13242 
    iprot.readStructEnd()
13243 
 
13244 
  def write(self, oprot):
13245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13247 
      return
13248 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13249 
    if self.success is not None:
2616 chandransh 13250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13251 
      oprot.writeBool(self.success)
13252 
      oprot.writeFieldEnd()
3431 rajveer 13253 
    if self.ex is not None:
2616 chandransh 13254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13255 
      self.ex.write(oprot)
13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
3431 rajveer 13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
2616 chandransh 13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
2690 chandransh 13275 
class getReturnOrders_args:
13276 
  """
13277 
  Attributes:
13278 
   - warehouseId
13279 
   - fromDate
13280 
   - toDate
13281 
  """
2616 chandransh 13282 
 
2690 chandransh 13283 
  thrift_spec = (
13284 
    None, # 0
13285 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13286 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13287 
    (3, TType.I64, 'toDate', None, None, ), # 3
13288 
  )
13289 
 
13290 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13291 
    self.warehouseId = warehouseId
13292 
    self.fromDate = fromDate
13293 
    self.toDate = toDate
13294 
 
13295 
  def read(self, iprot):
13296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13298 
      return
13299 
    iprot.readStructBegin()
13300 
    while True:
13301 
      (fname, ftype, fid) = iprot.readFieldBegin()
13302 
      if ftype == TType.STOP:
13303 
        break
13304 
      if fid == 1:
13305 
        if ftype == TType.I64:
13306 
          self.warehouseId = iprot.readI64();
13307 
        else:
13308 
          iprot.skip(ftype)
13309 
      elif fid == 2:
13310 
        if ftype == TType.I64:
13311 
          self.fromDate = iprot.readI64();
13312 
        else:
13313 
          iprot.skip(ftype)
13314 
      elif fid == 3:
13315 
        if ftype == TType.I64:
13316 
          self.toDate = iprot.readI64();
13317 
        else:
13318 
          iprot.skip(ftype)
13319 
      else:
13320 
        iprot.skip(ftype)
13321 
      iprot.readFieldEnd()
13322 
    iprot.readStructEnd()
13323 
 
13324 
  def write(self, oprot):
13325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13327 
      return
13328 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13329 
    if self.warehouseId is not None:
2690 chandransh 13330 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13331 
      oprot.writeI64(self.warehouseId)
13332 
      oprot.writeFieldEnd()
3431 rajveer 13333 
    if self.fromDate is not None:
2690 chandransh 13334 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13335 
      oprot.writeI64(self.fromDate)
13336 
      oprot.writeFieldEnd()
3431 rajveer 13337 
    if self.toDate is not None:
2690 chandransh 13338 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13339 
      oprot.writeI64(self.toDate)
13340 
      oprot.writeFieldEnd()
13341 
    oprot.writeFieldStop()
13342 
    oprot.writeStructEnd()
13343 
 
3431 rajveer 13344 
  def validate(self):
13345 
    return
13346 
 
13347 
 
2690 chandransh 13348 
  def __repr__(self):
13349 
    L = ['%s=%r' % (key, value)
13350 
      for key, value in self.__dict__.iteritems()]
13351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13352 
 
13353 
  def __eq__(self, other):
13354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13355 
 
13356 
  def __ne__(self, other):
13357 
    return not (self == other)
13358 
 
13359 
class getReturnOrders_result:
13360 
  """
13361 
  Attributes:
13362 
   - success
13363 
  """
13364 
 
13365 
  thrift_spec = (
13366 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13367 
  )
13368 
 
13369 
  def __init__(self, success=None,):
13370 
    self.success = success
13371 
 
13372 
  def read(self, iprot):
13373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13375 
      return
13376 
    iprot.readStructBegin()
13377 
    while True:
13378 
      (fname, ftype, fid) = iprot.readFieldBegin()
13379 
      if ftype == TType.STOP:
13380 
        break
13381 
      if fid == 0:
13382 
        if ftype == TType.LIST:
13383 
          self.success = []
4581 phani.kuma 13384 
          (_etype216, _size213) = iprot.readListBegin()
13385 
          for _i217 in xrange(_size213):
13386 
            _elem218 = ReturnOrder()
13387 
            _elem218.read(iprot)
13388 
            self.success.append(_elem218)
2690 chandransh 13389 
          iprot.readListEnd()
13390 
        else:
13391 
          iprot.skip(ftype)
13392 
      else:
13393 
        iprot.skip(ftype)
13394 
      iprot.readFieldEnd()
13395 
    iprot.readStructEnd()
13396 
 
13397 
  def write(self, oprot):
13398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13400 
      return
13401 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13402 
    if self.success is not None:
2690 chandransh 13403 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13404 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13405 
      for iter219 in self.success:
13406 
        iter219.write(oprot)
2690 chandransh 13407 
      oprot.writeListEnd()
13408 
      oprot.writeFieldEnd()
13409 
    oprot.writeFieldStop()
13410 
    oprot.writeStructEnd()
13411 
 
3431 rajveer 13412 
  def validate(self):
13413 
    return
13414 
 
13415 
 
2690 chandransh 13416 
  def __repr__(self):
13417 
    L = ['%s=%r' % (key, value)
13418 
      for key, value in self.__dict__.iteritems()]
13419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13420 
 
13421 
  def __eq__(self, other):
13422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13423 
 
13424 
  def __ne__(self, other):
13425 
    return not (self == other)
13426 
 
2700 chandransh 13427 
class getReturnOrder_args:
13428 
  """
13429 
  Attributes:
13430 
   - id
13431 
  """
13432 
 
13433 
  thrift_spec = (
13434 
    None, # 0
13435 
    (1, TType.I64, 'id', None, None, ), # 1
13436 
  )
13437 
 
13438 
  def __init__(self, id=None,):
13439 
    self.id = id
13440 
 
13441 
  def read(self, iprot):
13442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13444 
      return
13445 
    iprot.readStructBegin()
13446 
    while True:
13447 
      (fname, ftype, fid) = iprot.readFieldBegin()
13448 
      if ftype == TType.STOP:
13449 
        break
13450 
      if fid == 1:
13451 
        if ftype == TType.I64:
13452 
          self.id = iprot.readI64();
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      else:
13456 
        iprot.skip(ftype)
13457 
      iprot.readFieldEnd()
13458 
    iprot.readStructEnd()
13459 
 
13460 
  def write(self, oprot):
13461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13463 
      return
13464 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13465 
    if self.id is not None:
2700 chandransh 13466 
      oprot.writeFieldBegin('id', TType.I64, 1)
13467 
      oprot.writeI64(self.id)
13468 
      oprot.writeFieldEnd()
13469 
    oprot.writeFieldStop()
13470 
    oprot.writeStructEnd()
13471 
 
3431 rajveer 13472 
  def validate(self):
13473 
    return
13474 
 
13475 
 
2700 chandransh 13476 
  def __repr__(self):
13477 
    L = ['%s=%r' % (key, value)
13478 
      for key, value in self.__dict__.iteritems()]
13479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13480 
 
13481 
  def __eq__(self, other):
13482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13483 
 
13484 
  def __ne__(self, other):
13485 
    return not (self == other)
13486 
 
13487 
class getReturnOrder_result:
13488 
  """
13489 
  Attributes:
13490 
   - success
13491 
   - ex
13492 
  """
13493 
 
13494 
  thrift_spec = (
13495 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13497 
  )
13498 
 
13499 
  def __init__(self, success=None, ex=None,):
13500 
    self.success = success
13501 
    self.ex = ex
13502 
 
13503 
  def read(self, iprot):
13504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13506 
      return
13507 
    iprot.readStructBegin()
13508 
    while True:
13509 
      (fname, ftype, fid) = iprot.readFieldBegin()
13510 
      if ftype == TType.STOP:
13511 
        break
13512 
      if fid == 0:
13513 
        if ftype == TType.STRUCT:
13514 
          self.success = ReturnOrder()
13515 
          self.success.read(iprot)
13516 
        else:
13517 
          iprot.skip(ftype)
13518 
      elif fid == 1:
13519 
        if ftype == TType.STRUCT:
13520 
          self.ex = TransactionServiceException()
13521 
          self.ex.read(iprot)
13522 
        else:
13523 
          iprot.skip(ftype)
13524 
      else:
13525 
        iprot.skip(ftype)
13526 
      iprot.readFieldEnd()
13527 
    iprot.readStructEnd()
13528 
 
13529 
  def write(self, oprot):
13530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13532 
      return
13533 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13534 
    if self.success is not None:
2700 chandransh 13535 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13536 
      self.success.write(oprot)
13537 
      oprot.writeFieldEnd()
3431 rajveer 13538 
    if self.ex is not None:
2700 chandransh 13539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13540 
      self.ex.write(oprot)
13541 
      oprot.writeFieldEnd()
13542 
    oprot.writeFieldStop()
13543 
    oprot.writeStructEnd()
13544 
 
3431 rajveer 13545 
  def validate(self):
13546 
    return
13547 
 
13548 
 
2700 chandransh 13549 
  def __repr__(self):
13550 
    L = ['%s=%r' % (key, value)
13551 
      for key, value in self.__dict__.iteritems()]
13552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13553 
 
13554 
  def __eq__(self, other):
13555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13556 
 
13557 
  def __ne__(self, other):
13558 
    return not (self == other)
13559 
 
2690 chandransh 13560 
class processReturn_args:
13561 
  """
13562 
  Attributes:
13563 
   - returnOrderId
13564 
  """
13565 
 
13566 
  thrift_spec = (
13567 
    None, # 0
13568 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13569 
  )
13570 
 
13571 
  def __init__(self, returnOrderId=None,):
13572 
    self.returnOrderId = returnOrderId
13573 
 
13574 
  def read(self, iprot):
13575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13577 
      return
13578 
    iprot.readStructBegin()
13579 
    while True:
13580 
      (fname, ftype, fid) = iprot.readFieldBegin()
13581 
      if ftype == TType.STOP:
13582 
        break
13583 
      if fid == 1:
13584 
        if ftype == TType.I64:
13585 
          self.returnOrderId = iprot.readI64();
13586 
        else:
13587 
          iprot.skip(ftype)
13588 
      else:
13589 
        iprot.skip(ftype)
13590 
      iprot.readFieldEnd()
13591 
    iprot.readStructEnd()
13592 
 
13593 
  def write(self, oprot):
13594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13596 
      return
13597 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13598 
    if self.returnOrderId is not None:
2690 chandransh 13599 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13600 
      oprot.writeI64(self.returnOrderId)
13601 
      oprot.writeFieldEnd()
13602 
    oprot.writeFieldStop()
13603 
    oprot.writeStructEnd()
13604 
 
3431 rajveer 13605 
  def validate(self):
13606 
    return
13607 
 
13608 
 
2690 chandransh 13609 
  def __repr__(self):
13610 
    L = ['%s=%r' % (key, value)
13611 
      for key, value in self.__dict__.iteritems()]
13612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13613 
 
13614 
  def __eq__(self, other):
13615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13616 
 
13617 
  def __ne__(self, other):
13618 
    return not (self == other)
13619 
 
13620 
class processReturn_result:
13621 
  """
13622 
  Attributes:
13623 
   - ex
13624 
  """
13625 
 
13626 
  thrift_spec = (
13627 
    None, # 0
13628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13629 
  )
13630 
 
13631 
  def __init__(self, ex=None,):
13632 
    self.ex = ex
13633 
 
13634 
  def read(self, iprot):
13635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13637 
      return
13638 
    iprot.readStructBegin()
13639 
    while True:
13640 
      (fname, ftype, fid) = iprot.readFieldBegin()
13641 
      if ftype == TType.STOP:
13642 
        break
13643 
      if fid == 1:
13644 
        if ftype == TType.STRUCT:
13645 
          self.ex = TransactionServiceException()
13646 
          self.ex.read(iprot)
13647 
        else:
13648 
          iprot.skip(ftype)
13649 
      else:
13650 
        iprot.skip(ftype)
13651 
      iprot.readFieldEnd()
13652 
    iprot.readStructEnd()
13653 
 
13654 
  def write(self, oprot):
13655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13657 
      return
13658 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13659 
    if self.ex is not None:
2690 chandransh 13660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13661 
      self.ex.write(oprot)
13662 
      oprot.writeFieldEnd()
13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
3431 rajveer 13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
2690 chandransh 13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
2819 chandransh 13681 
class createPurchaseOrder_args:
13682 
  """
13683 
  Attributes:
13684 
   - warehouseId
13685 
  """
2690 chandransh 13686 
 
2819 chandransh 13687 
  thrift_spec = (
13688 
    None, # 0
13689 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13690 
  )
13691 
 
13692 
  def __init__(self, warehouseId=None,):
13693 
    self.warehouseId = warehouseId
13694 
 
13695 
  def read(self, iprot):
13696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13698 
      return
13699 
    iprot.readStructBegin()
13700 
    while True:
13701 
      (fname, ftype, fid) = iprot.readFieldBegin()
13702 
      if ftype == TType.STOP:
13703 
        break
13704 
      if fid == 1:
13705 
        if ftype == TType.I64:
13706 
          self.warehouseId = iprot.readI64();
13707 
        else:
13708 
          iprot.skip(ftype)
13709 
      else:
13710 
        iprot.skip(ftype)
13711 
      iprot.readFieldEnd()
13712 
    iprot.readStructEnd()
13713 
 
13714 
  def write(self, oprot):
13715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13717 
      return
13718 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13719 
    if self.warehouseId is not None:
2819 chandransh 13720 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13721 
      oprot.writeI64(self.warehouseId)
13722 
      oprot.writeFieldEnd()
13723 
    oprot.writeFieldStop()
13724 
    oprot.writeStructEnd()
13725 
 
3431 rajveer 13726 
  def validate(self):
13727 
    return
13728 
 
13729 
 
2819 chandransh 13730 
  def __repr__(self):
13731 
    L = ['%s=%r' % (key, value)
13732 
      for key, value in self.__dict__.iteritems()]
13733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13734 
 
13735 
  def __eq__(self, other):
13736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13737 
 
13738 
  def __ne__(self, other):
13739 
    return not (self == other)
13740 
 
13741 
class createPurchaseOrder_result:
13742 
  """
13743 
  Attributes:
13744 
   - success
13745 
   - ex
13746 
  """
13747 
 
13748 
  thrift_spec = (
4586 mandeep.dh 13749 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13751 
  )
13752 
 
13753 
  def __init__(self, success=None, ex=None,):
13754 
    self.success = success
13755 
    self.ex = ex
13756 
 
13757 
  def read(self, iprot):
13758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13760 
      return
13761 
    iprot.readStructBegin()
13762 
    while True:
13763 
      (fname, ftype, fid) = iprot.readFieldBegin()
13764 
      if ftype == TType.STOP:
13765 
        break
13766 
      if fid == 0:
4586 mandeep.dh 13767 
        if ftype == TType.LIST:
13768 
          self.success = []
13769 
          (_etype223, _size220) = iprot.readListBegin()
13770 
          for _i224 in xrange(_size220):
13771 
            _elem225 = iprot.readI64();
13772 
            self.success.append(_elem225)
13773 
          iprot.readListEnd()
2819 chandransh 13774 
        else:
13775 
          iprot.skip(ftype)
13776 
      elif fid == 1:
13777 
        if ftype == TType.STRUCT:
13778 
          self.ex = TransactionServiceException()
13779 
          self.ex.read(iprot)
13780 
        else:
13781 
          iprot.skip(ftype)
13782 
      else:
13783 
        iprot.skip(ftype)
13784 
      iprot.readFieldEnd()
13785 
    iprot.readStructEnd()
13786 
 
13787 
  def write(self, oprot):
13788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13790 
      return
13791 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13792 
    if self.success is not None:
4586 mandeep.dh 13793 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13794 
      oprot.writeListBegin(TType.I64, len(self.success))
13795 
      for iter226 in self.success:
13796 
        oprot.writeI64(iter226)
13797 
      oprot.writeListEnd()
2819 chandransh 13798 
      oprot.writeFieldEnd()
3431 rajveer 13799 
    if self.ex is not None:
2819 chandransh 13800 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13801 
      self.ex.write(oprot)
13802 
      oprot.writeFieldEnd()
13803 
    oprot.writeFieldStop()
13804 
    oprot.writeStructEnd()
13805 
 
3431 rajveer 13806 
  def validate(self):
13807 
    return
13808 
 
13809 
 
2819 chandransh 13810 
  def __repr__(self):
13811 
    L = ['%s=%r' % (key, value)
13812 
      for key, value in self.__dict__.iteritems()]
13813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13814 
 
13815 
  def __eq__(self, other):
13816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13817 
 
13818 
  def __ne__(self, other):
13819 
    return not (self == other)
3451 chandransh 13820 
 
13821 
class updateWeight_args:
13822 
  """
13823 
  Attributes:
13824 
   - orderId
13825 
   - weight
13826 
  """
13827 
 
13828 
  thrift_spec = (
13829 
    None, # 0
13830 
    (1, TType.I64, 'orderId', None, None, ), # 1
13831 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13832 
  )
13833 
 
13834 
  def __init__(self, orderId=None, weight=None,):
13835 
    self.orderId = orderId
13836 
    self.weight = weight
13837 
 
13838 
  def read(self, iprot):
13839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13841 
      return
13842 
    iprot.readStructBegin()
13843 
    while True:
13844 
      (fname, ftype, fid) = iprot.readFieldBegin()
13845 
      if ftype == TType.STOP:
13846 
        break
13847 
      if fid == 1:
13848 
        if ftype == TType.I64:
13849 
          self.orderId = iprot.readI64();
13850 
        else:
13851 
          iprot.skip(ftype)
13852 
      elif fid == 2:
13853 
        if ftype == TType.DOUBLE:
13854 
          self.weight = iprot.readDouble();
13855 
        else:
13856 
          iprot.skip(ftype)
13857 
      else:
13858 
        iprot.skip(ftype)
13859 
      iprot.readFieldEnd()
13860 
    iprot.readStructEnd()
13861 
 
13862 
  def write(self, oprot):
13863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13865 
      return
13866 
    oprot.writeStructBegin('updateWeight_args')
13867 
    if self.orderId is not None:
13868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13869 
      oprot.writeI64(self.orderId)
13870 
      oprot.writeFieldEnd()
13871 
    if self.weight is not None:
13872 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13873 
      oprot.writeDouble(self.weight)
13874 
      oprot.writeFieldEnd()
13875 
    oprot.writeFieldStop()
13876 
    oprot.writeStructEnd()
13877 
 
13878 
  def validate(self):
13879 
    return
13880 
 
13881 
 
13882 
  def __repr__(self):
13883 
    L = ['%s=%r' % (key, value)
13884 
      for key, value in self.__dict__.iteritems()]
13885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13886 
 
13887 
  def __eq__(self, other):
13888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13889 
 
13890 
  def __ne__(self, other):
13891 
    return not (self == other)
13892 
 
13893 
class updateWeight_result:
13894 
  """
13895 
  Attributes:
13896 
   - success
13897 
   - ex
13898 
  """
13899 
 
13900 
  thrift_spec = (
13901 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13903 
  )
13904 
 
13905 
  def __init__(self, success=None, ex=None,):
13906 
    self.success = success
13907 
    self.ex = ex
13908 
 
13909 
  def read(self, iprot):
13910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13912 
      return
13913 
    iprot.readStructBegin()
13914 
    while True:
13915 
      (fname, ftype, fid) = iprot.readFieldBegin()
13916 
      if ftype == TType.STOP:
13917 
        break
13918 
      if fid == 0:
13919 
        if ftype == TType.STRUCT:
13920 
          self.success = Order()
13921 
          self.success.read(iprot)
13922 
        else:
13923 
          iprot.skip(ftype)
13924 
      elif fid == 1:
13925 
        if ftype == TType.STRUCT:
13926 
          self.ex = TransactionServiceException()
13927 
          self.ex.read(iprot)
13928 
        else:
13929 
          iprot.skip(ftype)
13930 
      else:
13931 
        iprot.skip(ftype)
13932 
      iprot.readFieldEnd()
13933 
    iprot.readStructEnd()
13934 
 
13935 
  def write(self, oprot):
13936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13938 
      return
13939 
    oprot.writeStructBegin('updateWeight_result')
13940 
    if self.success is not None:
13941 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13942 
      self.success.write(oprot)
13943 
      oprot.writeFieldEnd()
13944 
    if self.ex is not None:
13945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13946 
      self.ex.write(oprot)
13947 
      oprot.writeFieldEnd()
13948 
    oprot.writeFieldStop()
13949 
    oprot.writeStructEnd()
13950 
 
13951 
  def validate(self):
13952 
    return
13953 
 
13954 
 
13955 
  def __repr__(self):
13956 
    L = ['%s=%r' % (key, value)
13957 
      for key, value in self.__dict__.iteritems()]
13958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13959 
 
13960 
  def __eq__(self, other):
13961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13962 
 
13963 
  def __ne__(self, other):
13964 
    return not (self == other)
3469 chandransh 13965 
 
13966 
class changeItem_args:
13967 
  """
13968 
  Attributes:
13969 
   - orderId
13970 
   - itemId
13971 
  """
13972 
 
13973 
  thrift_spec = (
13974 
    None, # 0
13975 
    (1, TType.I64, 'orderId', None, None, ), # 1
13976 
    (2, TType.I64, 'itemId', None, None, ), # 2
13977 
  )
13978 
 
13979 
  def __init__(self, orderId=None, itemId=None,):
13980 
    self.orderId = orderId
13981 
    self.itemId = itemId
13982 
 
13983 
  def read(self, iprot):
13984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13986 
      return
13987 
    iprot.readStructBegin()
13988 
    while True:
13989 
      (fname, ftype, fid) = iprot.readFieldBegin()
13990 
      if ftype == TType.STOP:
13991 
        break
13992 
      if fid == 1:
13993 
        if ftype == TType.I64:
13994 
          self.orderId = iprot.readI64();
13995 
        else:
13996 
          iprot.skip(ftype)
13997 
      elif fid == 2:
13998 
        if ftype == TType.I64:
13999 
          self.itemId = iprot.readI64();
14000 
        else:
14001 
          iprot.skip(ftype)
14002 
      else:
14003 
        iprot.skip(ftype)
14004 
      iprot.readFieldEnd()
14005 
    iprot.readStructEnd()
14006 
 
14007 
  def write(self, oprot):
14008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14010 
      return
14011 
    oprot.writeStructBegin('changeItem_args')
14012 
    if self.orderId is not None:
14013 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14014 
      oprot.writeI64(self.orderId)
14015 
      oprot.writeFieldEnd()
14016 
    if self.itemId is not None:
14017 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14018 
      oprot.writeI64(self.itemId)
14019 
      oprot.writeFieldEnd()
14020 
    oprot.writeFieldStop()
14021 
    oprot.writeStructEnd()
14022 
 
14023 
  def validate(self):
14024 
    return
14025 
 
14026 
 
14027 
  def __repr__(self):
14028 
    L = ['%s=%r' % (key, value)
14029 
      for key, value in self.__dict__.iteritems()]
14030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14031 
 
14032 
  def __eq__(self, other):
14033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14034 
 
14035 
  def __ne__(self, other):
14036 
    return not (self == other)
14037 
 
14038 
class changeItem_result:
14039 
  """
14040 
  Attributes:
14041 
   - success
14042 
   - ex
14043 
  """
14044 
 
14045 
  thrift_spec = (
14046 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14048 
  )
14049 
 
14050 
  def __init__(self, success=None, ex=None,):
14051 
    self.success = success
14052 
    self.ex = ex
14053 
 
14054 
  def read(self, iprot):
14055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14057 
      return
14058 
    iprot.readStructBegin()
14059 
    while True:
14060 
      (fname, ftype, fid) = iprot.readFieldBegin()
14061 
      if ftype == TType.STOP:
14062 
        break
14063 
      if fid == 0:
14064 
        if ftype == TType.STRUCT:
14065 
          self.success = Order()
14066 
          self.success.read(iprot)
14067 
        else:
14068 
          iprot.skip(ftype)
14069 
      elif fid == 1:
14070 
        if ftype == TType.STRUCT:
14071 
          self.ex = TransactionServiceException()
14072 
          self.ex.read(iprot)
14073 
        else:
14074 
          iprot.skip(ftype)
14075 
      else:
14076 
        iprot.skip(ftype)
14077 
      iprot.readFieldEnd()
14078 
    iprot.readStructEnd()
14079 
 
14080 
  def write(self, oprot):
14081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14083 
      return
14084 
    oprot.writeStructBegin('changeItem_result')
14085 
    if self.success is not None:
14086 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14087 
      self.success.write(oprot)
14088 
      oprot.writeFieldEnd()
14089 
    if self.ex is not None:
14090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14091 
      self.ex.write(oprot)
14092 
      oprot.writeFieldEnd()
14093 
    oprot.writeFieldStop()
14094 
    oprot.writeStructEnd()
14095 
 
14096 
  def validate(self):
14097 
    return
14098 
 
14099 
 
14100 
  def __repr__(self):
14101 
    L = ['%s=%r' % (key, value)
14102 
      for key, value in self.__dict__.iteritems()]
14103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14104 
 
14105 
  def __eq__(self, other):
14106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14107 
 
14108 
  def __ne__(self, other):
14109 
    return not (self == other)
14110 
 
14111 
class shiftToWarehouse_args:
14112 
  """
14113 
  Attributes:
14114 
   - orderId
14115 
   - warehouseId
14116 
  """
14117 
 
14118 
  thrift_spec = (
14119 
    None, # 0
14120 
    (1, TType.I64, 'orderId', None, None, ), # 1
14121 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14122 
  )
14123 
 
14124 
  def __init__(self, orderId=None, warehouseId=None,):
14125 
    self.orderId = orderId
14126 
    self.warehouseId = warehouseId
14127 
 
14128 
  def read(self, iprot):
14129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14131 
      return
14132 
    iprot.readStructBegin()
14133 
    while True:
14134 
      (fname, ftype, fid) = iprot.readFieldBegin()
14135 
      if ftype == TType.STOP:
14136 
        break
14137 
      if fid == 1:
14138 
        if ftype == TType.I64:
14139 
          self.orderId = iprot.readI64();
14140 
        else:
14141 
          iprot.skip(ftype)
14142 
      elif fid == 2:
14143 
        if ftype == TType.I64:
14144 
          self.warehouseId = iprot.readI64();
14145 
        else:
14146 
          iprot.skip(ftype)
14147 
      else:
14148 
        iprot.skip(ftype)
14149 
      iprot.readFieldEnd()
14150 
    iprot.readStructEnd()
14151 
 
14152 
  def write(self, oprot):
14153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14155 
      return
14156 
    oprot.writeStructBegin('shiftToWarehouse_args')
14157 
    if self.orderId is not None:
14158 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14159 
      oprot.writeI64(self.orderId)
14160 
      oprot.writeFieldEnd()
14161 
    if self.warehouseId is not None:
14162 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14163 
      oprot.writeI64(self.warehouseId)
14164 
      oprot.writeFieldEnd()
14165 
    oprot.writeFieldStop()
14166 
    oprot.writeStructEnd()
14167 
 
14168 
  def validate(self):
14169 
    return
14170 
 
14171 
 
14172 
  def __repr__(self):
14173 
    L = ['%s=%r' % (key, value)
14174 
      for key, value in self.__dict__.iteritems()]
14175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14176 
 
14177 
  def __eq__(self, other):
14178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14179 
 
14180 
  def __ne__(self, other):
14181 
    return not (self == other)
14182 
 
14183 
class shiftToWarehouse_result:
14184 
  """
14185 
  Attributes:
14186 
   - success
14187 
   - ex
14188 
  """
14189 
 
14190 
  thrift_spec = (
14191 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14193 
  )
14194 
 
14195 
  def __init__(self, success=None, ex=None,):
14196 
    self.success = success
14197 
    self.ex = ex
14198 
 
14199 
  def read(self, iprot):
14200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14202 
      return
14203 
    iprot.readStructBegin()
14204 
    while True:
14205 
      (fname, ftype, fid) = iprot.readFieldBegin()
14206 
      if ftype == TType.STOP:
14207 
        break
14208 
      if fid == 0:
14209 
        if ftype == TType.STRUCT:
14210 
          self.success = Order()
14211 
          self.success.read(iprot)
14212 
        else:
14213 
          iprot.skip(ftype)
14214 
      elif fid == 1:
14215 
        if ftype == TType.STRUCT:
14216 
          self.ex = TransactionServiceException()
14217 
          self.ex.read(iprot)
14218 
        else:
14219 
          iprot.skip(ftype)
14220 
      else:
14221 
        iprot.skip(ftype)
14222 
      iprot.readFieldEnd()
14223 
    iprot.readStructEnd()
14224 
 
14225 
  def write(self, oprot):
14226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14228 
      return
14229 
    oprot.writeStructBegin('shiftToWarehouse_result')
14230 
    if self.success is not None:
14231 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14232 
      self.success.write(oprot)
14233 
      oprot.writeFieldEnd()
14234 
    if self.ex is not None:
14235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14236 
      self.ex.write(oprot)
14237 
      oprot.writeFieldEnd()
14238 
    oprot.writeFieldStop()
14239 
    oprot.writeStructEnd()
14240 
 
14241 
  def validate(self):
14242 
    return
14243 
 
14244 
 
14245 
  def __repr__(self):
14246 
    L = ['%s=%r' % (key, value)
14247 
      for key, value in self.__dict__.iteritems()]
14248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14249 
 
14250 
  def __eq__(self, other):
14251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14252 
 
14253 
  def __ne__(self, other):
14254 
    return not (self == other)
3553 chandransh 14255 
 
14256 
class addDelayReason_args:
14257 
  """
14258 
  Attributes:
14259 
   - orderId
14260 
   - delayReason
3986 chandransh 14261 
   - furtherDelay
3553 chandransh 14262 
  """
14263 
 
14264 
  thrift_spec = (
14265 
    None, # 0
14266 
    (1, TType.I64, 'orderId', None, None, ), # 1
14267 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14268 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 14269 
  )
14270 
 
3986 chandransh 14271 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 14272 
    self.orderId = orderId
14273 
    self.delayReason = delayReason
3986 chandransh 14274 
    self.furtherDelay = furtherDelay
3553 chandransh 14275 
 
14276 
  def read(self, iprot):
14277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14279 
      return
14280 
    iprot.readStructBegin()
14281 
    while True:
14282 
      (fname, ftype, fid) = iprot.readFieldBegin()
14283 
      if ftype == TType.STOP:
14284 
        break
14285 
      if fid == 1:
14286 
        if ftype == TType.I64:
14287 
          self.orderId = iprot.readI64();
14288 
        else:
14289 
          iprot.skip(ftype)
14290 
      elif fid == 2:
14291 
        if ftype == TType.I32:
14292 
          self.delayReason = iprot.readI32();
14293 
        else:
14294 
          iprot.skip(ftype)
3986 chandransh 14295 
      elif fid == 3:
14296 
        if ftype == TType.I64:
14297 
          self.furtherDelay = iprot.readI64();
14298 
        else:
14299 
          iprot.skip(ftype)
3553 chandransh 14300 
      else:
14301 
        iprot.skip(ftype)
14302 
      iprot.readFieldEnd()
14303 
    iprot.readStructEnd()
14304 
 
14305 
  def write(self, oprot):
14306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14308 
      return
14309 
    oprot.writeStructBegin('addDelayReason_args')
14310 
    if self.orderId is not None:
14311 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14312 
      oprot.writeI64(self.orderId)
14313 
      oprot.writeFieldEnd()
14314 
    if self.delayReason is not None:
14315 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14316 
      oprot.writeI32(self.delayReason)
14317 
      oprot.writeFieldEnd()
3986 chandransh 14318 
    if self.furtherDelay is not None:
14319 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14320 
      oprot.writeI64(self.furtherDelay)
14321 
      oprot.writeFieldEnd()
3553 chandransh 14322 
    oprot.writeFieldStop()
14323 
    oprot.writeStructEnd()
14324 
 
14325 
  def validate(self):
14326 
    return
14327 
 
14328 
 
14329 
  def __repr__(self):
14330 
    L = ['%s=%r' % (key, value)
14331 
      for key, value in self.__dict__.iteritems()]
14332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14333 
 
14334 
  def __eq__(self, other):
14335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14336 
 
14337 
  def __ne__(self, other):
14338 
    return not (self == other)
14339 
 
14340 
class addDelayReason_result:
14341 
  """
14342 
  Attributes:
14343 
   - success
14344 
   - ex
14345 
  """
14346 
 
14347 
  thrift_spec = (
14348 
    (0, TType.BOOL, 'success', None, None, ), # 0
14349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14350 
  )
14351 
 
14352 
  def __init__(self, success=None, ex=None,):
14353 
    self.success = success
14354 
    self.ex = ex
14355 
 
14356 
  def read(self, iprot):
14357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14359 
      return
14360 
    iprot.readStructBegin()
14361 
    while True:
14362 
      (fname, ftype, fid) = iprot.readFieldBegin()
14363 
      if ftype == TType.STOP:
14364 
        break
14365 
      if fid == 0:
14366 
        if ftype == TType.BOOL:
14367 
          self.success = iprot.readBool();
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      elif fid == 1:
14371 
        if ftype == TType.STRUCT:
14372 
          self.ex = TransactionServiceException()
14373 
          self.ex.read(iprot)
14374 
        else:
14375 
          iprot.skip(ftype)
14376 
      else:
14377 
        iprot.skip(ftype)
14378 
      iprot.readFieldEnd()
14379 
    iprot.readStructEnd()
14380 
 
14381 
  def write(self, oprot):
14382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14384 
      return
14385 
    oprot.writeStructBegin('addDelayReason_result')
14386 
    if self.success is not None:
14387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14388 
      oprot.writeBool(self.success)
14389 
      oprot.writeFieldEnd()
14390 
    if self.ex is not None:
14391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14392 
      self.ex.write(oprot)
14393 
      oprot.writeFieldEnd()
14394 
    oprot.writeFieldStop()
14395 
    oprot.writeStructEnd()
14396 
 
14397 
  def validate(self):
14398 
    return
14399 
 
14400 
 
14401 
  def __repr__(self):
14402 
    L = ['%s=%r' % (key, value)
14403 
      for key, value in self.__dict__.iteritems()]
14404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14405 
 
14406 
  def __eq__(self, other):
14407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14408 
 
14409 
  def __ne__(self, other):
14410 
    return not (self == other)
3956 chandransh 14411 
 
14412 
class reconcileCodCollection_args:
14413 
  """
14414 
  Attributes:
14415 
   - collectedAmountMap
14416 
   - xferBy
14417 
   - xferTxnId
14418 
   - xferDate
14419 
  """
14420 
 
14421 
  thrift_spec = (
14422 
    None, # 0
14423 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14424 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14425 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14426 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14427 
  )
14428 
 
14429 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14430 
    self.collectedAmountMap = collectedAmountMap
14431 
    self.xferBy = xferBy
14432 
    self.xferTxnId = xferTxnId
14433 
    self.xferDate = xferDate
14434 
 
14435 
  def read(self, iprot):
14436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14438 
      return
14439 
    iprot.readStructBegin()
14440 
    while True:
14441 
      (fname, ftype, fid) = iprot.readFieldBegin()
14442 
      if ftype == TType.STOP:
14443 
        break
14444 
      if fid == 1:
14445 
        if ftype == TType.MAP:
14446 
          self.collectedAmountMap = {}
4586 mandeep.dh 14447 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14448 
          for _i231 in xrange(_size227):
14449 
            _key232 = iprot.readString();
14450 
            _val233 = iprot.readDouble();
14451 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14452 
          iprot.readMapEnd()
14453 
        else:
14454 
          iprot.skip(ftype)
14455 
      elif fid == 2:
14456 
        if ftype == TType.STRING:
14457 
          self.xferBy = iprot.readString();
14458 
        else:
14459 
          iprot.skip(ftype)
14460 
      elif fid == 3:
14461 
        if ftype == TType.STRING:
14462 
          self.xferTxnId = iprot.readString();
14463 
        else:
14464 
          iprot.skip(ftype)
14465 
      elif fid == 4:
14466 
        if ftype == TType.I64:
14467 
          self.xferDate = iprot.readI64();
14468 
        else:
14469 
          iprot.skip(ftype)
14470 
      else:
14471 
        iprot.skip(ftype)
14472 
      iprot.readFieldEnd()
14473 
    iprot.readStructEnd()
14474 
 
14475 
  def write(self, oprot):
14476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14478 
      return
14479 
    oprot.writeStructBegin('reconcileCodCollection_args')
14480 
    if self.collectedAmountMap is not None:
14481 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14482 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14483 
      for kiter234,viter235 in self.collectedAmountMap.items():
14484 
        oprot.writeString(kiter234)
14485 
        oprot.writeDouble(viter235)
3956 chandransh 14486 
      oprot.writeMapEnd()
14487 
      oprot.writeFieldEnd()
14488 
    if self.xferBy is not None:
14489 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14490 
      oprot.writeString(self.xferBy)
14491 
      oprot.writeFieldEnd()
14492 
    if self.xferTxnId is not None:
14493 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14494 
      oprot.writeString(self.xferTxnId)
14495 
      oprot.writeFieldEnd()
14496 
    if self.xferDate is not None:
14497 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14498 
      oprot.writeI64(self.xferDate)
14499 
      oprot.writeFieldEnd()
14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
14517 
 
14518 
class reconcileCodCollection_result:
14519 
  """
14520 
  Attributes:
14521 
   - success
14522 
   - ex
14523 
  """
14524 
 
14525 
  thrift_spec = (
14526 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14528 
  )
14529 
 
14530 
  def __init__(self, success=None, ex=None,):
14531 
    self.success = success
14532 
    self.ex = ex
14533 
 
14534 
  def read(self, iprot):
14535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14537 
      return
14538 
    iprot.readStructBegin()
14539 
    while True:
14540 
      (fname, ftype, fid) = iprot.readFieldBegin()
14541 
      if ftype == TType.STOP:
14542 
        break
14543 
      if fid == 0:
14544 
        if ftype == TType.MAP:
14545 
          self.success = {}
4586 mandeep.dh 14546 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14547 
          for _i240 in xrange(_size236):
14548 
            _key241 = iprot.readString();
14549 
            _val242 = iprot.readString();
14550 
            self.success[_key241] = _val242
3956 chandransh 14551 
          iprot.readMapEnd()
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      elif fid == 1:
14555 
        if ftype == TType.STRUCT:
14556 
          self.ex = TransactionServiceException()
14557 
          self.ex.read(iprot)
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
14569 
    oprot.writeStructBegin('reconcileCodCollection_result')
14570 
    if self.success is not None:
14571 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14572 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14573 
      for kiter243,viter244 in self.success.items():
14574 
        oprot.writeString(kiter243)
14575 
        oprot.writeString(viter244)
3956 chandransh 14576 
      oprot.writeMapEnd()
14577 
      oprot.writeFieldEnd()
14578 
    if self.ex is not None:
14579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14580 
      self.ex.write(oprot)
14581 
      oprot.writeFieldEnd()
14582 
    oprot.writeFieldStop()
14583 
    oprot.writeStructEnd()
14584 
 
14585 
  def validate(self):
14586 
    return
14587 
 
14588 
 
14589 
  def __repr__(self):
14590 
    L = ['%s=%r' % (key, value)
14591 
      for key, value in self.__dict__.iteritems()]
14592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14593 
 
14594 
  def __eq__(self, other):
14595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14596 
 
14597 
  def __ne__(self, other):
14598 
    return not (self == other)
4008 mandeep.dh 14599 
 
14600 
class getTransactionsRequiringExtraProcessing_args:
14601 
  """
14602 
  Attributes:
14603 
   - category
14604 
  """
14605 
 
14606 
  thrift_spec = (
14607 
    None, # 0
14608 
    (1, TType.I32, 'category', None, None, ), # 1
14609 
  )
14610 
 
14611 
  def __init__(self, category=None,):
14612 
    self.category = category
14613 
 
14614 
  def read(self, iprot):
14615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14617 
      return
14618 
    iprot.readStructBegin()
14619 
    while True:
14620 
      (fname, ftype, fid) = iprot.readFieldBegin()
14621 
      if ftype == TType.STOP:
14622 
        break
14623 
      if fid == 1:
14624 
        if ftype == TType.I32:
14625 
          self.category = iprot.readI32();
14626 
        else:
14627 
          iprot.skip(ftype)
14628 
      else:
14629 
        iprot.skip(ftype)
14630 
      iprot.readFieldEnd()
14631 
    iprot.readStructEnd()
14632 
 
14633 
  def write(self, oprot):
14634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14636 
      return
14637 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14638 
    if self.category is not None:
14639 
      oprot.writeFieldBegin('category', TType.I32, 1)
14640 
      oprot.writeI32(self.category)
14641 
      oprot.writeFieldEnd()
14642 
    oprot.writeFieldStop()
14643 
    oprot.writeStructEnd()
14644 
 
14645 
  def validate(self):
14646 
    return
14647 
 
14648 
 
14649 
  def __repr__(self):
14650 
    L = ['%s=%r' % (key, value)
14651 
      for key, value in self.__dict__.iteritems()]
14652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14653 
 
14654 
  def __eq__(self, other):
14655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14656 
 
14657 
  def __ne__(self, other):
14658 
    return not (self == other)
14659 
 
14660 
class getTransactionsRequiringExtraProcessing_result:
14661 
  """
14662 
  Attributes:
14663 
   - success
14664 
  """
14665 
 
14666 
  thrift_spec = (
14667 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14668 
  )
14669 
 
14670 
  def __init__(self, success=None,):
14671 
    self.success = success
14672 
 
14673 
  def read(self, iprot):
14674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14676 
      return
14677 
    iprot.readStructBegin()
14678 
    while True:
14679 
      (fname, ftype, fid) = iprot.readFieldBegin()
14680 
      if ftype == TType.STOP:
14681 
        break
14682 
      if fid == 0:
14683 
        if ftype == TType.LIST:
14684 
          self.success = []
4586 mandeep.dh 14685 
          (_etype248, _size245) = iprot.readListBegin()
14686 
          for _i249 in xrange(_size245):
14687 
            _elem250 = iprot.readI64();
14688 
            self.success.append(_elem250)
4008 mandeep.dh 14689 
          iprot.readListEnd()
14690 
        else:
14691 
          iprot.skip(ftype)
14692 
      else:
14693 
        iprot.skip(ftype)
14694 
      iprot.readFieldEnd()
14695 
    iprot.readStructEnd()
14696 
 
14697 
  def write(self, oprot):
14698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14700 
      return
14701 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14702 
    if self.success is not None:
14703 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14704 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14705 
      for iter251 in self.success:
14706 
        oprot.writeI64(iter251)
4008 mandeep.dh 14707 
      oprot.writeListEnd()
14708 
      oprot.writeFieldEnd()
14709 
    oprot.writeFieldStop()
14710 
    oprot.writeStructEnd()
14711 
 
14712 
  def validate(self):
14713 
    return
14714 
 
14715 
 
14716 
  def __repr__(self):
14717 
    L = ['%s=%r' % (key, value)
14718 
      for key, value in self.__dict__.iteritems()]
14719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14720 
 
14721 
  def __eq__(self, other):
14722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14723 
 
14724 
  def __ne__(self, other):
14725 
    return not (self == other)
14726 
 
14727 
class markTransactionAsProcessed_args:
14728 
  """
14729 
  Attributes:
14730 
   - transactionId
14731 
   - category
14732 
  """
14733 
 
14734 
  thrift_spec = (
14735 
    None, # 0
14736 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14737 
    (2, TType.I32, 'category', None, None, ), # 2
14738 
  )
14739 
 
14740 
  def __init__(self, transactionId=None, category=None,):
14741 
    self.transactionId = transactionId
14742 
    self.category = category
14743 
 
14744 
  def read(self, iprot):
14745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14747 
      return
14748 
    iprot.readStructBegin()
14749 
    while True:
14750 
      (fname, ftype, fid) = iprot.readFieldBegin()
14751 
      if ftype == TType.STOP:
14752 
        break
14753 
      if fid == 1:
14754 
        if ftype == TType.I64:
14755 
          self.transactionId = iprot.readI64();
14756 
        else:
14757 
          iprot.skip(ftype)
14758 
      elif fid == 2:
14759 
        if ftype == TType.I32:
14760 
          self.category = iprot.readI32();
14761 
        else:
14762 
          iprot.skip(ftype)
14763 
      else:
14764 
        iprot.skip(ftype)
14765 
      iprot.readFieldEnd()
14766 
    iprot.readStructEnd()
14767 
 
14768 
  def write(self, oprot):
14769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14771 
      return
14772 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14773 
    if self.transactionId is not None:
14774 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14775 
      oprot.writeI64(self.transactionId)
14776 
      oprot.writeFieldEnd()
14777 
    if self.category is not None:
14778 
      oprot.writeFieldBegin('category', TType.I32, 2)
14779 
      oprot.writeI32(self.category)
14780 
      oprot.writeFieldEnd()
14781 
    oprot.writeFieldStop()
14782 
    oprot.writeStructEnd()
14783 
 
14784 
  def validate(self):
14785 
    return
14786 
 
14787 
 
14788 
  def __repr__(self):
14789 
    L = ['%s=%r' % (key, value)
14790 
      for key, value in self.__dict__.iteritems()]
14791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14792 
 
14793 
  def __eq__(self, other):
14794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14795 
 
14796 
  def __ne__(self, other):
14797 
    return not (self == other)
14798 
 
14799 
class markTransactionAsProcessed_result:
14800 
 
14801 
  thrift_spec = (
14802 
  )
14803 
 
14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
14813 
      else:
14814 
        iprot.skip(ftype)
14815 
      iprot.readFieldEnd()
14816 
    iprot.readStructEnd()
14817 
 
14818 
  def write(self, oprot):
14819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14821 
      return
14822 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14823 
    oprot.writeFieldStop()
14824 
    oprot.writeStructEnd()
14825 
 
14826 
  def validate(self):
14827 
    return
14828 
 
14829 
 
14830 
  def __repr__(self):
14831 
    L = ['%s=%r' % (key, value)
14832 
      for key, value in self.__dict__.iteritems()]
14833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14834 
 
14835 
  def __eq__(self, other):
14836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14837 
 
14838 
  def __ne__(self, other):
14839 
    return not (self == other)
4018 chandransh 14840 
 
14841 
class getItemWiseRiskyOrdersCount_args:
14842 
 
14843 
  thrift_spec = (
14844 
  )
14845 
 
14846 
  def read(self, iprot):
14847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14849 
      return
14850 
    iprot.readStructBegin()
14851 
    while True:
14852 
      (fname, ftype, fid) = iprot.readFieldBegin()
14853 
      if ftype == TType.STOP:
14854 
        break
14855 
      else:
14856 
        iprot.skip(ftype)
14857 
      iprot.readFieldEnd()
14858 
    iprot.readStructEnd()
14859 
 
14860 
  def write(self, oprot):
14861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14863 
      return
14864 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14865 
    oprot.writeFieldStop()
14866 
    oprot.writeStructEnd()
14867 
 
14868 
  def validate(self):
14869 
    return
14870 
 
14871 
 
14872 
  def __repr__(self):
14873 
    L = ['%s=%r' % (key, value)
14874 
      for key, value in self.__dict__.iteritems()]
14875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14876 
 
14877 
  def __eq__(self, other):
14878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14879 
 
14880 
  def __ne__(self, other):
14881 
    return not (self == other)
14882 
 
14883 
class getItemWiseRiskyOrdersCount_result:
14884 
  """
14885 
  Attributes:
14886 
   - success
14887 
  """
14888 
 
14889 
  thrift_spec = (
14890 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14891 
  )
14892 
 
14893 
  def __init__(self, success=None,):
14894 
    self.success = success
14895 
 
14896 
  def read(self, iprot):
14897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14899 
      return
14900 
    iprot.readStructBegin()
14901 
    while True:
14902 
      (fname, ftype, fid) = iprot.readFieldBegin()
14903 
      if ftype == TType.STOP:
14904 
        break
14905 
      if fid == 0:
14906 
        if ftype == TType.MAP:
14907 
          self.success = {}
4586 mandeep.dh 14908 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
14909 
          for _i256 in xrange(_size252):
14910 
            _key257 = iprot.readI64();
14911 
            _val258 = iprot.readI64();
14912 
            self.success[_key257] = _val258
4018 chandransh 14913 
          iprot.readMapEnd()
14914 
        else:
14915 
          iprot.skip(ftype)
14916 
      else:
14917 
        iprot.skip(ftype)
14918 
      iprot.readFieldEnd()
14919 
    iprot.readStructEnd()
14920 
 
14921 
  def write(self, oprot):
14922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14924 
      return
14925 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14926 
    if self.success is not None:
14927 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14928 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 14929 
      for kiter259,viter260 in self.success.items():
14930 
        oprot.writeI64(kiter259)
14931 
        oprot.writeI64(viter260)
4018 chandransh 14932 
      oprot.writeMapEnd()
14933 
      oprot.writeFieldEnd()
14934 
    oprot.writeFieldStop()
14935 
    oprot.writeStructEnd()
14936 
 
14937 
  def validate(self):
14938 
    return
14939 
 
14940 
 
14941 
  def __repr__(self):
14942 
    L = ['%s=%r' % (key, value)
14943 
      for key, value in self.__dict__.iteritems()]
14944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14945 
 
14946 
  def __eq__(self, other):
14947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14948 
 
14949 
  def __ne__(self, other):
14950 
    return not (self == other)
4247 rajveer 14951 
 
4295 varun.gupt 14952 
class getOrdersForItemIds_args:
14953 
  """
14954 
  Attributes:
14955 
   - itemIds
14956 
  """
14957 
 
14958 
  thrift_spec = (
14959 
    None, # 0
14960 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14961 
  )
14962 
 
14963 
  def __init__(self, itemIds=None,):
14964 
    self.itemIds = itemIds
14965 
 
14966 
  def read(self, iprot):
14967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14969 
      return
14970 
    iprot.readStructBegin()
14971 
    while True:
14972 
      (fname, ftype, fid) = iprot.readFieldBegin()
14973 
      if ftype == TType.STOP:
14974 
        break
14975 
      if fid == 1:
14976 
        if ftype == TType.LIST:
14977 
          self.itemIds = []
4586 mandeep.dh 14978 
          (_etype264, _size261) = iprot.readListBegin()
14979 
          for _i265 in xrange(_size261):
14980 
            _elem266 = iprot.readI64();
14981 
            self.itemIds.append(_elem266)
4295 varun.gupt 14982 
          iprot.readListEnd()
14983 
        else:
14984 
          iprot.skip(ftype)
14985 
      else:
14986 
        iprot.skip(ftype)
14987 
      iprot.readFieldEnd()
14988 
    iprot.readStructEnd()
14989 
 
14990 
  def write(self, oprot):
14991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14993 
      return
14994 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14995 
    if self.itemIds is not None:
14996 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14997 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 14998 
      for iter267 in self.itemIds:
14999 
        oprot.writeI64(iter267)
4295 varun.gupt 15000 
      oprot.writeListEnd()
15001 
      oprot.writeFieldEnd()
15002 
    oprot.writeFieldStop()
15003 
    oprot.writeStructEnd()
15004 
 
15005 
  def validate(self):
15006 
    return
15007 
 
15008 
 
15009 
  def __repr__(self):
15010 
    L = ['%s=%r' % (key, value)
15011 
      for key, value in self.__dict__.iteritems()]
15012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15013 
 
15014 
  def __eq__(self, other):
15015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15016 
 
15017 
  def __ne__(self, other):
15018 
    return not (self == other)
15019 
 
15020 
class getOrdersForItemIds_result:
15021 
  """
15022 
  Attributes:
15023 
   - success
15024 
  """
15025 
 
15026 
  thrift_spec = (
15027 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15028 
  )
15029 
 
15030 
  def __init__(self, success=None,):
15031 
    self.success = success
15032 
 
15033 
  def read(self, iprot):
15034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15036 
      return
15037 
    iprot.readStructBegin()
15038 
    while True:
15039 
      (fname, ftype, fid) = iprot.readFieldBegin()
15040 
      if ftype == TType.STOP:
15041 
        break
15042 
      if fid == 0:
15043 
        if ftype == TType.LIST:
15044 
          self.success = []
4586 mandeep.dh 15045 
          (_etype271, _size268) = iprot.readListBegin()
15046 
          for _i272 in xrange(_size268):
15047 
            _elem273 = Order()
15048 
            _elem273.read(iprot)
15049 
            self.success.append(_elem273)
4295 varun.gupt 15050 
          iprot.readListEnd()
15051 
        else:
15052 
          iprot.skip(ftype)
15053 
      else:
15054 
        iprot.skip(ftype)
15055 
      iprot.readFieldEnd()
15056 
    iprot.readStructEnd()
15057 
 
15058 
  def write(self, oprot):
15059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15061 
      return
15062 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15063 
    if self.success is not None:
15064 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15065 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15066 
      for iter274 in self.success:
15067 
        iter274.write(oprot)
4295 varun.gupt 15068 
      oprot.writeListEnd()
15069 
      oprot.writeFieldEnd()
15070 
    oprot.writeFieldStop()
15071 
    oprot.writeStructEnd()
15072 
 
15073 
  def validate(self):
15074 
    return
15075 
 
15076 
 
15077 
  def __repr__(self):
15078 
    L = ['%s=%r' % (key, value)
15079 
      for key, value in self.__dict__.iteritems()]
15080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15081 
 
15082 
  def __eq__(self, other):
15083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15084 
 
15085 
  def __ne__(self, other):
15086 
    return not (self == other)
15087 
 
4247 rajveer 15088 
class markOrderCancellationRequestReceived_args:
15089 
  """
15090 
  Attributes:
15091 
   - orderId
15092 
  """
15093 
 
15094 
  thrift_spec = (
15095 
    None, # 0
15096 
    (1, TType.I64, 'orderId', None, None, ), # 1
15097 
  )
15098 
 
15099 
  def __init__(self, orderId=None,):
15100 
    self.orderId = orderId
15101 
 
15102 
  def read(self, iprot):
15103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15105 
      return
15106 
    iprot.readStructBegin()
15107 
    while True:
15108 
      (fname, ftype, fid) = iprot.readFieldBegin()
15109 
      if ftype == TType.STOP:
15110 
        break
15111 
      if fid == 1:
15112 
        if ftype == TType.I64:
15113 
          self.orderId = iprot.readI64();
15114 
        else:
15115 
          iprot.skip(ftype)
15116 
      else:
15117 
        iprot.skip(ftype)
15118 
      iprot.readFieldEnd()
15119 
    iprot.readStructEnd()
15120 
 
15121 
  def write(self, oprot):
15122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15124 
      return
15125 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15126 
    if self.orderId is not None:
15127 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15128 
      oprot.writeI64(self.orderId)
15129 
      oprot.writeFieldEnd()
15130 
    oprot.writeFieldStop()
15131 
    oprot.writeStructEnd()
15132 
 
15133 
  def validate(self):
15134 
    return
15135 
 
15136 
 
15137 
  def __repr__(self):
15138 
    L = ['%s=%r' % (key, value)
15139 
      for key, value in self.__dict__.iteritems()]
15140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15141 
 
15142 
  def __eq__(self, other):
15143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15144 
 
15145 
  def __ne__(self, other):
15146 
    return not (self == other)
15147 
 
15148 
class markOrderCancellationRequestReceived_result:
15149 
  """
15150 
  Attributes:
15151 
   - ex
15152 
  """
15153 
 
15154 
  thrift_spec = (
15155 
    None, # 0
15156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15157 
  )
15158 
 
15159 
  def __init__(self, ex=None,):
15160 
    self.ex = ex
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 1:
15172 
        if ftype == TType.STRUCT:
15173 
          self.ex = TransactionServiceException()
15174 
          self.ex.read(iprot)
15175 
        else:
15176 
          iprot.skip(ftype)
15177 
      else:
15178 
        iprot.skip(ftype)
15179 
      iprot.readFieldEnd()
15180 
    iprot.readStructEnd()
15181 
 
15182 
  def write(self, oprot):
15183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15185 
      return
15186 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15187 
    if self.ex is not None:
15188 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15189 
      self.ex.write(oprot)
15190 
      oprot.writeFieldEnd()
15191 
    oprot.writeFieldStop()
15192 
    oprot.writeStructEnd()
15193 
 
15194 
  def validate(self):
15195 
    return
15196 
 
15197 
 
15198 
  def __repr__(self):
15199 
    L = ['%s=%r' % (key, value)
15200 
      for key, value in self.__dict__.iteritems()]
15201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15202 
 
15203 
  def __eq__(self, other):
15204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15205 
 
15206 
  def __ne__(self, other):
15207 
    return not (self == other)
15208 
 
15209 
class markOrderCancellationRequestConfirmed_args:
15210 
  """
15211 
  Attributes:
15212 
   - orderId
15213 
  """
15214 
 
15215 
  thrift_spec = (
15216 
    None, # 0
15217 
    (1, TType.I64, 'orderId', None, None, ), # 1
15218 
  )
15219 
 
15220 
  def __init__(self, orderId=None,):
15221 
    self.orderId = orderId
15222 
 
15223 
  def read(self, iprot):
15224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15226 
      return
15227 
    iprot.readStructBegin()
15228 
    while True:
15229 
      (fname, ftype, fid) = iprot.readFieldBegin()
15230 
      if ftype == TType.STOP:
15231 
        break
15232 
      if fid == 1:
15233 
        if ftype == TType.I64:
15234 
          self.orderId = iprot.readI64();
15235 
        else:
15236 
          iprot.skip(ftype)
15237 
      else:
15238 
        iprot.skip(ftype)
15239 
      iprot.readFieldEnd()
15240 
    iprot.readStructEnd()
15241 
 
15242 
  def write(self, oprot):
15243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15245 
      return
15246 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15247 
    if self.orderId is not None:
15248 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15249 
      oprot.writeI64(self.orderId)
15250 
      oprot.writeFieldEnd()
15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
15269 
class markOrderCancellationRequestConfirmed_result:
15270 
  """
15271 
  Attributes:
15272 
   - ex
15273 
  """
15274 
 
15275 
  thrift_spec = (
15276 
    None, # 0
15277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15278 
  )
15279 
 
15280 
  def __init__(self, ex=None,):
15281 
    self.ex = ex
15282 
 
15283 
  def read(self, iprot):
15284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15286 
      return
15287 
    iprot.readStructBegin()
15288 
    while True:
15289 
      (fname, ftype, fid) = iprot.readFieldBegin()
15290 
      if ftype == TType.STOP:
15291 
        break
15292 
      if fid == 1:
15293 
        if ftype == TType.STRUCT:
15294 
          self.ex = TransactionServiceException()
15295 
          self.ex.read(iprot)
15296 
        else:
15297 
          iprot.skip(ftype)
15298 
      else:
15299 
        iprot.skip(ftype)
15300 
      iprot.readFieldEnd()
15301 
    iprot.readStructEnd()
15302 
 
15303 
  def write(self, oprot):
15304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15306 
      return
15307 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15308 
    if self.ex is not None:
15309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15310 
      self.ex.write(oprot)
15311 
      oprot.writeFieldEnd()
15312 
    oprot.writeFieldStop()
15313 
    oprot.writeStructEnd()
15314 
 
15315 
  def validate(self):
15316 
    return
15317 
 
15318 
 
15319 
  def __repr__(self):
15320 
    L = ['%s=%r' % (key, value)
15321 
      for key, value in self.__dict__.iteritems()]
15322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15323 
 
15324 
  def __eq__(self, other):
15325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15326 
 
15327 
  def __ne__(self, other):
15328 
    return not (self == other)
15329 
 
15330 
class markOrderCancellationRequestDenied_args:
15331 
  """
15332 
  Attributes:
15333 
   - orderId
15334 
  """
15335 
 
15336 
  thrift_spec = (
15337 
    None, # 0
15338 
    (1, TType.I64, 'orderId', None, None, ), # 1
15339 
  )
15340 
 
15341 
  def __init__(self, orderId=None,):
15342 
    self.orderId = orderId
15343 
 
15344 
  def read(self, iprot):
15345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15347 
      return
15348 
    iprot.readStructBegin()
15349 
    while True:
15350 
      (fname, ftype, fid) = iprot.readFieldBegin()
15351 
      if ftype == TType.STOP:
15352 
        break
15353 
      if fid == 1:
15354 
        if ftype == TType.I64:
15355 
          self.orderId = iprot.readI64();
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15368 
    if self.orderId is not None:
15369 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15370 
      oprot.writeI64(self.orderId)
15371 
      oprot.writeFieldEnd()
15372 
    oprot.writeFieldStop()
15373 
    oprot.writeStructEnd()
15374 
 
15375 
  def validate(self):
15376 
    return
15377 
 
15378 
 
15379 
  def __repr__(self):
15380 
    L = ['%s=%r' % (key, value)
15381 
      for key, value in self.__dict__.iteritems()]
15382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15383 
 
15384 
  def __eq__(self, other):
15385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15386 
 
15387 
  def __ne__(self, other):
15388 
    return not (self == other)
15389 
 
15390 
class markOrderCancellationRequestDenied_result:
15391 
  """
15392 
  Attributes:
15393 
   - ex
15394 
  """
15395 
 
15396 
  thrift_spec = (
15397 
    None, # 0
15398 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15399 
  )
15400 
 
15401 
  def __init__(self, ex=None,):
15402 
    self.ex = ex
15403 
 
15404 
  def read(self, iprot):
15405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15407 
      return
15408 
    iprot.readStructBegin()
15409 
    while True:
15410 
      (fname, ftype, fid) = iprot.readFieldBegin()
15411 
      if ftype == TType.STOP:
15412 
        break
15413 
      if fid == 1:
15414 
        if ftype == TType.STRUCT:
15415 
          self.ex = TransactionServiceException()
15416 
          self.ex.read(iprot)
15417 
        else:
15418 
          iprot.skip(ftype)
15419 
      else:
15420 
        iprot.skip(ftype)
15421 
      iprot.readFieldEnd()
15422 
    iprot.readStructEnd()
15423 
 
15424 
  def write(self, oprot):
15425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15427 
      return
15428 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15429 
    if self.ex is not None:
15430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15431 
      self.ex.write(oprot)
15432 
      oprot.writeFieldEnd()
15433 
    oprot.writeFieldStop()
15434 
    oprot.writeStructEnd()
15435 
 
15436 
  def validate(self):
15437 
    return
15438 
 
15439 
 
15440 
  def __repr__(self):
15441 
    L = ['%s=%r' % (key, value)
15442 
      for key, value in self.__dict__.iteritems()]
15443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15444 
 
15445 
  def __eq__(self, other):
15446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15447 
 
15448 
  def __ne__(self, other):
15449 
    return not (self == other)
15450 
 
4258 rajveer 15451 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15452 
  """
15453 
  Attributes:
4258 rajveer 15454 
   - transactionId
4247 rajveer 15455 
  """
15456 
 
15457 
  thrift_spec = (
15458 
    None, # 0
4258 rajveer 15459 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15460 
  )
15461 
 
4258 rajveer 15462 
  def __init__(self, transactionId=None,):
15463 
    self.transactionId = transactionId
4247 rajveer 15464 
 
15465 
  def read(self, iprot):
15466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15468 
      return
15469 
    iprot.readStructBegin()
15470 
    while True:
15471 
      (fname, ftype, fid) = iprot.readFieldBegin()
15472 
      if ftype == TType.STOP:
15473 
        break
15474 
      if fid == 1:
15475 
        if ftype == TType.I64:
4258 rajveer 15476 
          self.transactionId = iprot.readI64();
4247 rajveer 15477 
        else:
15478 
          iprot.skip(ftype)
15479 
      else:
15480 
        iprot.skip(ftype)
15481 
      iprot.readFieldEnd()
15482 
    iprot.readStructEnd()
15483 
 
15484 
  def write(self, oprot):
15485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15487 
      return
4258 rajveer 15488 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15489 
    if self.transactionId is not None:
15490 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15491 
      oprot.writeI64(self.transactionId)
4247 rajveer 15492 
      oprot.writeFieldEnd()
15493 
    oprot.writeFieldStop()
15494 
    oprot.writeStructEnd()
15495 
 
15496 
  def validate(self):
15497 
    return
15498 
 
15499 
 
15500 
  def __repr__(self):
15501 
    L = ['%s=%r' % (key, value)
15502 
      for key, value in self.__dict__.iteritems()]
15503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15504 
 
15505 
  def __eq__(self, other):
15506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15507 
 
15508 
  def __ne__(self, other):
15509 
    return not (self == other)
15510 
 
4258 rajveer 15511 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15512 
  """
15513 
  Attributes:
15514 
   - ex
15515 
  """
15516 
 
15517 
  thrift_spec = (
15518 
    None, # 0
15519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15520 
  )
15521 
 
15522 
  def __init__(self, ex=None,):
15523 
    self.ex = ex
15524 
 
15525 
  def read(self, iprot):
15526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15528 
      return
15529 
    iprot.readStructBegin()
15530 
    while True:
15531 
      (fname, ftype, fid) = iprot.readFieldBegin()
15532 
      if ftype == TType.STOP:
15533 
        break
15534 
      if fid == 1:
15535 
        if ftype == TType.STRUCT:
15536 
          self.ex = TransactionServiceException()
15537 
          self.ex.read(iprot)
15538 
        else:
15539 
          iprot.skip(ftype)
15540 
      else:
15541 
        iprot.skip(ftype)
15542 
      iprot.readFieldEnd()
15543 
    iprot.readStructEnd()
15544 
 
15545 
  def write(self, oprot):
15546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15548 
      return
4258 rajveer 15549 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15550 
    if self.ex is not None:
15551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15552 
      self.ex.write(oprot)
15553 
      oprot.writeFieldEnd()
15554 
    oprot.writeFieldStop()
15555 
    oprot.writeStructEnd()
15556 
 
15557 
  def validate(self):
15558 
    return
15559 
 
15560 
 
15561 
  def __repr__(self):
15562 
    L = ['%s=%r' % (key, value)
15563 
      for key, value in self.__dict__.iteritems()]
15564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15565 
 
15566 
  def __eq__(self, other):
15567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15568 
 
15569 
  def __ne__(self, other):
15570 
    return not (self == other)
4259 anupam.sin 15571 
 
15572 
class refundTransaction_args:
15573 
  """
15574 
  Attributes:
15575 
   - transactionId
15576 
   - refundedBy
15577 
   - reason
15578 
  """
15579 
 
15580 
  thrift_spec = (
15581 
    None, # 0
15582 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15583 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15584 
    (3, TType.STRING, 'reason', None, None, ), # 3
15585 
  )
15586 
 
15587 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15588 
    self.transactionId = transactionId
15589 
    self.refundedBy = refundedBy
15590 
    self.reason = reason
15591 
 
15592 
  def read(self, iprot):
15593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15595 
      return
15596 
    iprot.readStructBegin()
15597 
    while True:
15598 
      (fname, ftype, fid) = iprot.readFieldBegin()
15599 
      if ftype == TType.STOP:
15600 
        break
15601 
      if fid == 1:
15602 
        if ftype == TType.I64:
15603 
          self.transactionId = iprot.readI64();
15604 
        else:
15605 
          iprot.skip(ftype)
15606 
      elif fid == 2:
15607 
        if ftype == TType.STRING:
15608 
          self.refundedBy = iprot.readString();
15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      elif fid == 3:
15612 
        if ftype == TType.STRING:
15613 
          self.reason = iprot.readString();
15614 
        else:
15615 
          iprot.skip(ftype)
15616 
      else:
15617 
        iprot.skip(ftype)
15618 
      iprot.readFieldEnd()
15619 
    iprot.readStructEnd()
15620 
 
15621 
  def write(self, oprot):
15622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15624 
      return
15625 
    oprot.writeStructBegin('refundTransaction_args')
15626 
    if self.transactionId is not None:
15627 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15628 
      oprot.writeI64(self.transactionId)
15629 
      oprot.writeFieldEnd()
15630 
    if self.refundedBy is not None:
15631 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15632 
      oprot.writeString(self.refundedBy)
15633 
      oprot.writeFieldEnd()
15634 
    if self.reason is not None:
15635 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15636 
      oprot.writeString(self.reason)
15637 
      oprot.writeFieldEnd()
15638 
    oprot.writeFieldStop()
15639 
    oprot.writeStructEnd()
15640 
 
15641 
  def validate(self):
15642 
    return
15643 
 
15644 
 
15645 
  def __repr__(self):
15646 
    L = ['%s=%r' % (key, value)
15647 
      for key, value in self.__dict__.iteritems()]
15648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15649 
 
15650 
  def __eq__(self, other):
15651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15652 
 
15653 
  def __ne__(self, other):
15654 
    return not (self == other)
15655 
 
15656 
class refundTransaction_result:
15657 
  """
15658 
  Attributes:
15659 
   - ex
15660 
  """
15661 
 
15662 
  thrift_spec = (
15663 
    None, # 0
15664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15665 
  )
15666 
 
15667 
  def __init__(self, ex=None,):
15668 
    self.ex = ex
15669 
 
15670 
  def read(self, iprot):
15671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15673 
      return
15674 
    iprot.readStructBegin()
15675 
    while True:
15676 
      (fname, ftype, fid) = iprot.readFieldBegin()
15677 
      if ftype == TType.STOP:
15678 
        break
15679 
      if fid == 1:
15680 
        if ftype == TType.STRUCT:
15681 
          self.ex = TransactionServiceException()
15682 
          self.ex.read(iprot)
15683 
        else:
15684 
          iprot.skip(ftype)
15685 
      else:
15686 
        iprot.skip(ftype)
15687 
      iprot.readFieldEnd()
15688 
    iprot.readStructEnd()
15689 
 
15690 
  def write(self, oprot):
15691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15693 
      return
15694 
    oprot.writeStructBegin('refundTransaction_result')
15695 
    if self.ex is not None:
15696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15697 
      self.ex.write(oprot)
15698 
      oprot.writeFieldEnd()
15699 
    oprot.writeFieldStop()
15700 
    oprot.writeStructEnd()
15701 
 
15702 
  def validate(self):
15703 
    return
15704 
 
15705 
 
15706 
  def __repr__(self):
15707 
    L = ['%s=%r' % (key, value)
15708 
      for key, value in self.__dict__.iteritems()]
15709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15710 
 
15711 
  def __eq__(self, other):
15712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15713 
 
15714 
  def __ne__(self, other):
15715 
    return not (self == other)
4285 rajveer 15716 
 
4324 mandeep.dh 15717 
class updateShipmentAddress_args:
15718 
  """
15719 
  Attributes:
15720 
   - orderId
15721 
   - addressId
15722 
  """
15723 
 
15724 
  thrift_spec = (
15725 
    None, # 0
15726 
    (1, TType.I64, 'orderId', None, None, ), # 1
15727 
    (2, TType.I64, 'addressId', None, None, ), # 2
15728 
  )
15729 
 
15730 
  def __init__(self, orderId=None, addressId=None,):
15731 
    self.orderId = orderId
15732 
    self.addressId = addressId
15733 
 
15734 
  def read(self, iprot):
15735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15737 
      return
15738 
    iprot.readStructBegin()
15739 
    while True:
15740 
      (fname, ftype, fid) = iprot.readFieldBegin()
15741 
      if ftype == TType.STOP:
15742 
        break
15743 
      if fid == 1:
15744 
        if ftype == TType.I64:
15745 
          self.orderId = iprot.readI64();
15746 
        else:
15747 
          iprot.skip(ftype)
15748 
      elif fid == 2:
15749 
        if ftype == TType.I64:
15750 
          self.addressId = iprot.readI64();
15751 
        else:
15752 
          iprot.skip(ftype)
15753 
      else:
15754 
        iprot.skip(ftype)
15755 
      iprot.readFieldEnd()
15756 
    iprot.readStructEnd()
15757 
 
15758 
  def write(self, oprot):
15759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15761 
      return
15762 
    oprot.writeStructBegin('updateShipmentAddress_args')
15763 
    if self.orderId is not None:
15764 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15765 
      oprot.writeI64(self.orderId)
15766 
      oprot.writeFieldEnd()
15767 
    if self.addressId is not None:
15768 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15769 
      oprot.writeI64(self.addressId)
15770 
      oprot.writeFieldEnd()
15771 
    oprot.writeFieldStop()
15772 
    oprot.writeStructEnd()
15773 
 
15774 
  def validate(self):
15775 
    return
15776 
 
15777 
 
15778 
  def __repr__(self):
15779 
    L = ['%s=%r' % (key, value)
15780 
      for key, value in self.__dict__.iteritems()]
15781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15782 
 
15783 
  def __eq__(self, other):
15784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15785 
 
15786 
  def __ne__(self, other):
15787 
    return not (self == other)
15788 
 
15789 
class updateShipmentAddress_result:
15790 
  """
15791 
  Attributes:
15792 
   - ex
15793 
  """
15794 
 
15795 
  thrift_spec = (
15796 
    None, # 0
15797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15798 
  )
15799 
 
15800 
  def __init__(self, ex=None,):
15801 
    self.ex = ex
15802 
 
15803 
  def read(self, iprot):
15804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15806 
      return
15807 
    iprot.readStructBegin()
15808 
    while True:
15809 
      (fname, ftype, fid) = iprot.readFieldBegin()
15810 
      if ftype == TType.STOP:
15811 
        break
15812 
      if fid == 1:
15813 
        if ftype == TType.STRUCT:
15814 
          self.ex = TransactionServiceException()
15815 
          self.ex.read(iprot)
15816 
        else:
15817 
          iprot.skip(ftype)
15818 
      else:
15819 
        iprot.skip(ftype)
15820 
      iprot.readFieldEnd()
15821 
    iprot.readStructEnd()
15822 
 
15823 
  def write(self, oprot):
15824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15826 
      return
15827 
    oprot.writeStructBegin('updateShipmentAddress_result')
15828 
    if self.ex is not None:
15829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15830 
      self.ex.write(oprot)
15831 
      oprot.writeFieldEnd()
15832 
    oprot.writeFieldStop()
15833 
    oprot.writeStructEnd()
15834 
 
15835 
  def validate(self):
15836 
    return
15837 
 
15838 
 
15839 
  def __repr__(self):
15840 
    L = ['%s=%r' % (key, value)
15841 
      for key, value in self.__dict__.iteritems()]
15842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15843 
 
15844 
  def __eq__(self, other):
15845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15846 
 
15847 
  def __ne__(self, other):
15848 
    return not (self == other)
15849 
 
4285 rajveer 15850 
class acceptOrdersForItemId_args:
15851 
  """
15852 
  Attributes:
15853 
   - itemId
15854 
   - inventory
15855 
  """
15856 
 
15857 
  thrift_spec = (
15858 
    None, # 0
15859 
    (1, TType.I64, 'itemId', None, None, ), # 1
15860 
    (2, TType.I64, 'inventory', None, None, ), # 2
15861 
  )
15862 
 
15863 
  def __init__(self, itemId=None, inventory=None,):
15864 
    self.itemId = itemId
15865 
    self.inventory = inventory
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 1:
15877 
        if ftype == TType.I64:
15878 
          self.itemId = iprot.readI64();
15879 
        else:
15880 
          iprot.skip(ftype)
15881 
      elif fid == 2:
15882 
        if ftype == TType.I64:
15883 
          self.inventory = iprot.readI64();
15884 
        else:
15885 
          iprot.skip(ftype)
15886 
      else:
15887 
        iprot.skip(ftype)
15888 
      iprot.readFieldEnd()
15889 
    iprot.readStructEnd()
15890 
 
15891 
  def write(self, oprot):
15892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15894 
      return
15895 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15896 
    if self.itemId is not None:
15897 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15898 
      oprot.writeI64(self.itemId)
15899 
      oprot.writeFieldEnd()
15900 
    if self.inventory is not None:
15901 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15902 
      oprot.writeI64(self.inventory)
15903 
      oprot.writeFieldEnd()
15904 
    oprot.writeFieldStop()
15905 
    oprot.writeStructEnd()
15906 
 
15907 
  def validate(self):
15908 
    return
15909 
 
15910 
 
15911 
  def __repr__(self):
15912 
    L = ['%s=%r' % (key, value)
15913 
      for key, value in self.__dict__.iteritems()]
15914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15915 
 
15916 
  def __eq__(self, other):
15917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15918 
 
15919 
  def __ne__(self, other):
15920 
    return not (self == other)
15921 
 
15922 
class acceptOrdersForItemId_result:
15923 
  """
15924 
  Attributes:
15925 
   - success
15926 
   - ex
15927 
  """
15928 
 
15929 
  thrift_spec = (
15930 
    (0, TType.BOOL, 'success', None, None, ), # 0
15931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15932 
  )
15933 
 
15934 
  def __init__(self, success=None, ex=None,):
15935 
    self.success = success
15936 
    self.ex = ex
15937 
 
15938 
  def read(self, iprot):
15939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15941 
      return
15942 
    iprot.readStructBegin()
15943 
    while True:
15944 
      (fname, ftype, fid) = iprot.readFieldBegin()
15945 
      if ftype == TType.STOP:
15946 
        break
15947 
      if fid == 0:
15948 
        if ftype == TType.BOOL:
15949 
          self.success = iprot.readBool();
15950 
        else:
15951 
          iprot.skip(ftype)
15952 
      elif fid == 1:
15953 
        if ftype == TType.STRUCT:
15954 
          self.ex = TransactionServiceException()
15955 
          self.ex.read(iprot)
15956 
        else:
15957 
          iprot.skip(ftype)
15958 
      else:
15959 
        iprot.skip(ftype)
15960 
      iprot.readFieldEnd()
15961 
    iprot.readStructEnd()
15962 
 
15963 
  def write(self, oprot):
15964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15966 
      return
15967 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15968 
    if self.success is not None:
15969 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15970 
      oprot.writeBool(self.success)
15971 
      oprot.writeFieldEnd()
15972 
    if self.ex is not None:
15973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15974 
      self.ex.write(oprot)
15975 
      oprot.writeFieldEnd()
15976 
    oprot.writeFieldStop()
15977 
    oprot.writeStructEnd()
15978 
 
15979 
  def validate(self):
15980 
    return
15981 
 
15982 
 
15983 
  def __repr__(self):
15984 
    L = ['%s=%r' % (key, value)
15985 
      for key, value in self.__dict__.iteritems()]
15986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15987 
 
15988 
  def __eq__(self, other):
15989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15990 
 
15991 
  def __ne__(self, other):
15992 
    return not (self == other)
4303 rajveer 15993 
 
15994 
class markOrdersAsPORaised_args:
15995 
  """
15996 
  Attributes:
15997 
   - vendorId
15998 
   - itemId
15999 
   - quantity
16000 
   - estimate
4369 rajveer 16001 
   - isReminder
4303 rajveer 16002 
  """
16003 
 
16004 
  thrift_spec = (
16005 
    None, # 0
16006 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16007 
    (2, TType.I64, 'itemId', None, None, ), # 2
16008 
    (3, TType.I64, 'quantity', None, None, ), # 3
16009 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16010 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16011 
  )
16012 
 
4369 rajveer 16013 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16014 
    self.vendorId = vendorId
16015 
    self.itemId = itemId
16016 
    self.quantity = quantity
16017 
    self.estimate = estimate
4369 rajveer 16018 
    self.isReminder = isReminder
4303 rajveer 16019 
 
16020 
  def read(self, iprot):
16021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16023 
      return
16024 
    iprot.readStructBegin()
16025 
    while True:
16026 
      (fname, ftype, fid) = iprot.readFieldBegin()
16027 
      if ftype == TType.STOP:
16028 
        break
16029 
      if fid == 1:
16030 
        if ftype == TType.I64:
16031 
          self.vendorId = iprot.readI64();
16032 
        else:
16033 
          iprot.skip(ftype)
16034 
      elif fid == 2:
16035 
        if ftype == TType.I64:
16036 
          self.itemId = iprot.readI64();
16037 
        else:
16038 
          iprot.skip(ftype)
16039 
      elif fid == 3:
16040 
        if ftype == TType.I64:
16041 
          self.quantity = iprot.readI64();
16042 
        else:
16043 
          iprot.skip(ftype)
16044 
      elif fid == 4:
16045 
        if ftype == TType.I64:
16046 
          self.estimate = iprot.readI64();
16047 
        else:
16048 
          iprot.skip(ftype)
4369 rajveer 16049 
      elif fid == 5:
16050 
        if ftype == TType.BOOL:
16051 
          self.isReminder = iprot.readBool();
16052 
        else:
16053 
          iprot.skip(ftype)
4303 rajveer 16054 
      else:
16055 
        iprot.skip(ftype)
16056 
      iprot.readFieldEnd()
16057 
    iprot.readStructEnd()
16058 
 
16059 
  def write(self, oprot):
16060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16062 
      return
16063 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16064 
    if self.vendorId is not None:
16065 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16066 
      oprot.writeI64(self.vendorId)
16067 
      oprot.writeFieldEnd()
16068 
    if self.itemId is not None:
16069 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16070 
      oprot.writeI64(self.itemId)
16071 
      oprot.writeFieldEnd()
16072 
    if self.quantity is not None:
16073 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16074 
      oprot.writeI64(self.quantity)
16075 
      oprot.writeFieldEnd()
16076 
    if self.estimate is not None:
16077 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16078 
      oprot.writeI64(self.estimate)
16079 
      oprot.writeFieldEnd()
4369 rajveer 16080 
    if self.isReminder is not None:
16081 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16082 
      oprot.writeBool(self.isReminder)
16083 
      oprot.writeFieldEnd()
4303 rajveer 16084 
    oprot.writeFieldStop()
16085 
    oprot.writeStructEnd()
16086 
 
16087 
  def validate(self):
16088 
    return
16089 
 
16090 
 
16091 
  def __repr__(self):
16092 
    L = ['%s=%r' % (key, value)
16093 
      for key, value in self.__dict__.iteritems()]
16094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16095 
 
16096 
  def __eq__(self, other):
16097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16098 
 
16099 
  def __ne__(self, other):
16100 
    return not (self == other)
16101 
 
16102 
class markOrdersAsPORaised_result:
16103 
  """
16104 
  Attributes:
16105 
   - ex
16106 
  """
16107 
 
16108 
  thrift_spec = (
16109 
    None, # 0
16110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16111 
  )
16112 
 
16113 
  def __init__(self, ex=None,):
16114 
    self.ex = ex
16115 
 
16116 
  def read(self, iprot):
16117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16119 
      return
16120 
    iprot.readStructBegin()
16121 
    while True:
16122 
      (fname, ftype, fid) = iprot.readFieldBegin()
16123 
      if ftype == TType.STOP:
16124 
        break
16125 
      if fid == 1:
16126 
        if ftype == TType.STRUCT:
16127 
          self.ex = TransactionServiceException()
16128 
          self.ex.read(iprot)
16129 
        else:
16130 
          iprot.skip(ftype)
16131 
      else:
16132 
        iprot.skip(ftype)
16133 
      iprot.readFieldEnd()
16134 
    iprot.readStructEnd()
16135 
 
16136 
  def write(self, oprot):
16137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16139 
      return
16140 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16141 
    if self.ex is not None:
16142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16143 
      self.ex.write(oprot)
16144 
      oprot.writeFieldEnd()
16145 
    oprot.writeFieldStop()
16146 
    oprot.writeStructEnd()
16147 
 
16148 
  def validate(self):
16149 
    return
16150 
 
16151 
 
16152 
  def __repr__(self):
16153 
    L = ['%s=%r' % (key, value)
16154 
      for key, value in self.__dict__.iteritems()]
16155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16156 
 
16157 
  def __eq__(self, other):
16158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16159 
 
16160 
  def __ne__(self, other):
16161 
    return not (self == other)
16162 
 
16163 
class markOrdersAsReversalInitiated_args:
16164 
  """
16165 
  Attributes:
16166 
   - vendorId
16167 
   - itemId
16168 
   - quantity
16169 
   - estimate
4369 rajveer 16170 
   - isReminder
4303 rajveer 16171 
  """
16172 
 
16173 
  thrift_spec = (
16174 
    None, # 0
16175 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16176 
    (2, TType.I64, 'itemId', None, None, ), # 2
16177 
    (3, TType.I64, 'quantity', None, None, ), # 3
16178 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16179 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16180 
  )
16181 
 
4369 rajveer 16182 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16183 
    self.vendorId = vendorId
16184 
    self.itemId = itemId
16185 
    self.quantity = quantity
16186 
    self.estimate = estimate
4369 rajveer 16187 
    self.isReminder = isReminder
4303 rajveer 16188 
 
16189 
  def read(self, iprot):
16190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16192 
      return
16193 
    iprot.readStructBegin()
16194 
    while True:
16195 
      (fname, ftype, fid) = iprot.readFieldBegin()
16196 
      if ftype == TType.STOP:
16197 
        break
16198 
      if fid == 1:
16199 
        if ftype == TType.I64:
16200 
          self.vendorId = iprot.readI64();
16201 
        else:
16202 
          iprot.skip(ftype)
16203 
      elif fid == 2:
16204 
        if ftype == TType.I64:
16205 
          self.itemId = iprot.readI64();
16206 
        else:
16207 
          iprot.skip(ftype)
16208 
      elif fid == 3:
16209 
        if ftype == TType.I64:
16210 
          self.quantity = iprot.readI64();
16211 
        else:
16212 
          iprot.skip(ftype)
16213 
      elif fid == 4:
16214 
        if ftype == TType.I64:
16215 
          self.estimate = iprot.readI64();
16216 
        else:
16217 
          iprot.skip(ftype)
4369 rajveer 16218 
      elif fid == 5:
16219 
        if ftype == TType.BOOL:
16220 
          self.isReminder = iprot.readBool();
16221 
        else:
16222 
          iprot.skip(ftype)
4303 rajveer 16223 
      else:
16224 
        iprot.skip(ftype)
16225 
      iprot.readFieldEnd()
16226 
    iprot.readStructEnd()
16227 
 
16228 
  def write(self, oprot):
16229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16231 
      return
16232 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16233 
    if self.vendorId is not None:
16234 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16235 
      oprot.writeI64(self.vendorId)
16236 
      oprot.writeFieldEnd()
16237 
    if self.itemId is not None:
16238 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16239 
      oprot.writeI64(self.itemId)
16240 
      oprot.writeFieldEnd()
16241 
    if self.quantity is not None:
16242 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16243 
      oprot.writeI64(self.quantity)
16244 
      oprot.writeFieldEnd()
16245 
    if self.estimate is not None:
16246 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16247 
      oprot.writeI64(self.estimate)
16248 
      oprot.writeFieldEnd()
4369 rajveer 16249 
    if self.isReminder is not None:
16250 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16251 
      oprot.writeBool(self.isReminder)
16252 
      oprot.writeFieldEnd()
4303 rajveer 16253 
    oprot.writeFieldStop()
16254 
    oprot.writeStructEnd()
16255 
 
16256 
  def validate(self):
16257 
    return
16258 
 
16259 
 
16260 
  def __repr__(self):
16261 
    L = ['%s=%r' % (key, value)
16262 
      for key, value in self.__dict__.iteritems()]
16263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16264 
 
16265 
  def __eq__(self, other):
16266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16267 
 
16268 
  def __ne__(self, other):
16269 
    return not (self == other)
16270 
 
16271 
class markOrdersAsReversalInitiated_result:
16272 
  """
16273 
  Attributes:
16274 
   - ex
16275 
  """
16276 
 
16277 
  thrift_spec = (
16278 
    None, # 0
16279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16280 
  )
16281 
 
16282 
  def __init__(self, ex=None,):
16283 
    self.ex = ex
16284 
 
16285 
  def read(self, iprot):
16286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16288 
      return
16289 
    iprot.readStructBegin()
16290 
    while True:
16291 
      (fname, ftype, fid) = iprot.readFieldBegin()
16292 
      if ftype == TType.STOP:
16293 
        break
16294 
      if fid == 1:
16295 
        if ftype == TType.STRUCT:
16296 
          self.ex = TransactionServiceException()
16297 
          self.ex.read(iprot)
16298 
        else:
16299 
          iprot.skip(ftype)
16300 
      else:
16301 
        iprot.skip(ftype)
16302 
      iprot.readFieldEnd()
16303 
    iprot.readStructEnd()
16304 
 
16305 
  def write(self, oprot):
16306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16308 
      return
16309 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16310 
    if self.ex is not None:
16311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16312 
      self.ex.write(oprot)
16313 
      oprot.writeFieldEnd()
16314 
    oprot.writeFieldStop()
16315 
    oprot.writeStructEnd()
16316 
 
16317 
  def validate(self):
16318 
    return
16319 
 
16320 
 
16321 
  def __repr__(self):
16322 
    L = ['%s=%r' % (key, value)
16323 
      for key, value in self.__dict__.iteritems()]
16324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16325 
 
16326 
  def __eq__(self, other):
16327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16328 
 
16329 
  def __ne__(self, other):
16330 
    return not (self == other)
16331 
 
16332 
class markOrdersAsNotAvailabke_args:
16333 
  """
16334 
  Attributes:
16335 
   - vendorId
16336 
   - itemId
16337 
   - quantity
16338 
   - estimate
4369 rajveer 16339 
   - isReminder
4303 rajveer 16340 
  """
16341 
 
16342 
  thrift_spec = (
16343 
    None, # 0
16344 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16345 
    (2, TType.I64, 'itemId', None, None, ), # 2
16346 
    (3, TType.I64, 'quantity', None, None, ), # 3
16347 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16348 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16349 
  )
16350 
 
4369 rajveer 16351 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16352 
    self.vendorId = vendorId
16353 
    self.itemId = itemId
16354 
    self.quantity = quantity
16355 
    self.estimate = estimate
4369 rajveer 16356 
    self.isReminder = isReminder
4303 rajveer 16357 
 
16358 
  def read(self, iprot):
16359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16361 
      return
16362 
    iprot.readStructBegin()
16363 
    while True:
16364 
      (fname, ftype, fid) = iprot.readFieldBegin()
16365 
      if ftype == TType.STOP:
16366 
        break
16367 
      if fid == 1:
16368 
        if ftype == TType.I64:
16369 
          self.vendorId = iprot.readI64();
16370 
        else:
16371 
          iprot.skip(ftype)
16372 
      elif fid == 2:
16373 
        if ftype == TType.I64:
16374 
          self.itemId = iprot.readI64();
16375 
        else:
16376 
          iprot.skip(ftype)
16377 
      elif fid == 3:
16378 
        if ftype == TType.I64:
16379 
          self.quantity = iprot.readI64();
16380 
        else:
16381 
          iprot.skip(ftype)
16382 
      elif fid == 4:
16383 
        if ftype == TType.I64:
16384 
          self.estimate = iprot.readI64();
16385 
        else:
16386 
          iprot.skip(ftype)
4369 rajveer 16387 
      elif fid == 5:
16388 
        if ftype == TType.BOOL:
16389 
          self.isReminder = iprot.readBool();
16390 
        else:
16391 
          iprot.skip(ftype)
4303 rajveer 16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16402 
    if self.vendorId is not None:
16403 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16404 
      oprot.writeI64(self.vendorId)
16405 
      oprot.writeFieldEnd()
16406 
    if self.itemId is not None:
16407 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16408 
      oprot.writeI64(self.itemId)
16409 
      oprot.writeFieldEnd()
16410 
    if self.quantity is not None:
16411 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16412 
      oprot.writeI64(self.quantity)
16413 
      oprot.writeFieldEnd()
16414 
    if self.estimate is not None:
16415 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16416 
      oprot.writeI64(self.estimate)
16417 
      oprot.writeFieldEnd()
4369 rajveer 16418 
    if self.isReminder is not None:
16419 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16420 
      oprot.writeBool(self.isReminder)
16421 
      oprot.writeFieldEnd()
4303 rajveer 16422 
    oprot.writeFieldStop()
16423 
    oprot.writeStructEnd()
16424 
 
16425 
  def validate(self):
16426 
    return
16427 
 
16428 
 
16429 
  def __repr__(self):
16430 
    L = ['%s=%r' % (key, value)
16431 
      for key, value in self.__dict__.iteritems()]
16432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16433 
 
16434 
  def __eq__(self, other):
16435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16436 
 
16437 
  def __ne__(self, other):
16438 
    return not (self == other)
16439 
 
16440 
class markOrdersAsNotAvailabke_result:
16441 
  """
16442 
  Attributes:
16443 
   - ex
16444 
  """
16445 
 
16446 
  thrift_spec = (
16447 
    None, # 0
16448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16449 
  )
16450 
 
16451 
  def __init__(self, ex=None,):
16452 
    self.ex = ex
16453 
 
16454 
  def read(self, iprot):
16455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16457 
      return
16458 
    iprot.readStructBegin()
16459 
    while True:
16460 
      (fname, ftype, fid) = iprot.readFieldBegin()
16461 
      if ftype == TType.STOP:
16462 
        break
16463 
      if fid == 1:
16464 
        if ftype == TType.STRUCT:
16465 
          self.ex = TransactionServiceException()
16466 
          self.ex.read(iprot)
16467 
        else:
16468 
          iprot.skip(ftype)
16469 
      else:
16470 
        iprot.skip(ftype)
16471 
      iprot.readFieldEnd()
16472 
    iprot.readStructEnd()
16473 
 
16474 
  def write(self, oprot):
16475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16477 
      return
16478 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16479 
    if self.ex is not None:
16480 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16481 
      self.ex.write(oprot)
16482 
      oprot.writeFieldEnd()
16483 
    oprot.writeFieldStop()
16484 
    oprot.writeStructEnd()
16485 
 
16486 
  def validate(self):
16487 
    return
16488 
 
16489 
 
16490 
  def __repr__(self):
16491 
    L = ['%s=%r' % (key, value)
16492 
      for key, value in self.__dict__.iteritems()]
16493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16494 
 
16495 
  def __eq__(self, other):
16496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16497 
 
16498 
  def __ne__(self, other):
16499 
    return not (self == other)
4369 rajveer 16500 
 
16501 
class markOrdersAsTimeout_args:
16502 
  """
16503 
  Attributes:
16504 
   - vendorId
16505 
  """
16506 
 
16507 
  thrift_spec = (
16508 
    None, # 0
16509 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16510 
  )
16511 
 
16512 
  def __init__(self, vendorId=None,):
16513 
    self.vendorId = vendorId
16514 
 
16515 
  def read(self, iprot):
16516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16518 
      return
16519 
    iprot.readStructBegin()
16520 
    while True:
16521 
      (fname, ftype, fid) = iprot.readFieldBegin()
16522 
      if ftype == TType.STOP:
16523 
        break
16524 
      if fid == 1:
16525 
        if ftype == TType.I64:
16526 
          self.vendorId = iprot.readI64();
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16539 
    if self.vendorId is not None:
16540 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16541 
      oprot.writeI64(self.vendorId)
16542 
      oprot.writeFieldEnd()
16543 
    oprot.writeFieldStop()
16544 
    oprot.writeStructEnd()
16545 
 
16546 
  def validate(self):
16547 
    return
16548 
 
16549 
 
16550 
  def __repr__(self):
16551 
    L = ['%s=%r' % (key, value)
16552 
      for key, value in self.__dict__.iteritems()]
16553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16554 
 
16555 
  def __eq__(self, other):
16556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16557 
 
16558 
  def __ne__(self, other):
16559 
    return not (self == other)
16560 
 
16561 
class markOrdersAsTimeout_result:
16562 
  """
16563 
  Attributes:
16564 
   - success
16565 
   - ex
16566 
  """
16567 
 
16568 
  thrift_spec = (
16569 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16571 
  )
16572 
 
16573 
  def __init__(self, success=None, ex=None,):
16574 
    self.success = success
16575 
    self.ex = ex
16576 
 
16577 
  def read(self, iprot):
16578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16580 
      return
16581 
    iprot.readStructBegin()
16582 
    while True:
16583 
      (fname, ftype, fid) = iprot.readFieldBegin()
16584 
      if ftype == TType.STOP:
16585 
        break
16586 
      if fid == 0:
16587 
        if ftype == TType.MAP:
16588 
          self.success = {}
4586 mandeep.dh 16589 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16590 
          for _i279 in xrange(_size275):
16591 
            _key280 = iprot.readI32();
16592 
            _val281 = TimeoutSummary()
16593 
            _val281.read(iprot)
16594 
            self.success[_key280] = _val281
4369 rajveer 16595 
          iprot.readMapEnd()
16596 
        else:
16597 
          iprot.skip(ftype)
16598 
      elif fid == 1:
16599 
        if ftype == TType.STRUCT:
16600 
          self.ex = TransactionServiceException()
16601 
          self.ex.read(iprot)
16602 
        else:
16603 
          iprot.skip(ftype)
16604 
      else:
16605 
        iprot.skip(ftype)
16606 
      iprot.readFieldEnd()
16607 
    iprot.readStructEnd()
16608 
 
16609 
  def write(self, oprot):
16610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16612 
      return
16613 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16614 
    if self.success is not None:
16615 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16616 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16617 
      for kiter282,viter283 in self.success.items():
16618 
        oprot.writeI32(kiter282)
16619 
        viter283.write(oprot)
4369 rajveer 16620 
      oprot.writeMapEnd()
16621 
      oprot.writeFieldEnd()
16622 
    if self.ex is not None:
16623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16624 
      self.ex.write(oprot)
16625 
      oprot.writeFieldEnd()
16626 
    oprot.writeFieldStop()
16627 
    oprot.writeStructEnd()
16628 
 
16629 
  def validate(self):
16630 
    return
16631 
 
16632 
 
16633 
  def __repr__(self):
16634 
    L = ['%s=%r' % (key, value)
16635 
      for key, value in self.__dict__.iteritems()]
16636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16637 
 
16638 
  def __eq__(self, other):
16639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16640 
 
16641 
  def __ne__(self, other):
16642 
    return not (self == other)
4386 anupam.sin 16643 
 
16644 
class getOrderForAwb_args:
16645 
  """
16646 
  Attributes:
16647 
   - awb
16648 
  """
16649 
 
16650 
  thrift_spec = (
16651 
    None, # 0
16652 
    (1, TType.STRING, 'awb', None, None, ), # 1
16653 
  )
16654 
 
16655 
  def __init__(self, awb=None,):
16656 
    self.awb = awb
16657 
 
16658 
  def read(self, iprot):
16659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16661 
      return
16662 
    iprot.readStructBegin()
16663 
    while True:
16664 
      (fname, ftype, fid) = iprot.readFieldBegin()
16665 
      if ftype == TType.STOP:
16666 
        break
16667 
      if fid == 1:
16668 
        if ftype == TType.STRING:
16669 
          self.awb = iprot.readString();
16670 
        else:
16671 
          iprot.skip(ftype)
16672 
      else:
16673 
        iprot.skip(ftype)
16674 
      iprot.readFieldEnd()
16675 
    iprot.readStructEnd()
16676 
 
16677 
  def write(self, oprot):
16678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16680 
      return
16681 
    oprot.writeStructBegin('getOrderForAwb_args')
16682 
    if self.awb is not None:
16683 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16684 
      oprot.writeString(self.awb)
16685 
      oprot.writeFieldEnd()
16686 
    oprot.writeFieldStop()
16687 
    oprot.writeStructEnd()
16688 
 
16689 
  def validate(self):
16690 
    return
16691 
 
16692 
 
16693 
  def __repr__(self):
16694 
    L = ['%s=%r' % (key, value)
16695 
      for key, value in self.__dict__.iteritems()]
16696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16697 
 
16698 
  def __eq__(self, other):
16699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16700 
 
16701 
  def __ne__(self, other):
16702 
    return not (self == other)
16703 
 
16704 
class getOrderForAwb_result:
16705 
  """
16706 
  Attributes:
16707 
   - success
16708 
   - ex
16709 
  """
16710 
 
16711 
  thrift_spec = (
16712 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16714 
  )
16715 
 
16716 
  def __init__(self, success=None, ex=None,):
16717 
    self.success = success
16718 
    self.ex = ex
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      if fid == 0:
16730 
        if ftype == TType.STRUCT:
16731 
          self.success = Order()
16732 
          self.success.read(iprot)
16733 
        else:
16734 
          iprot.skip(ftype)
16735 
      elif fid == 1:
16736 
        if ftype == TType.STRUCT:
16737 
          self.ex = TransactionServiceException()
16738 
          self.ex.read(iprot)
16739 
        else:
16740 
          iprot.skip(ftype)
16741 
      else:
16742 
        iprot.skip(ftype)
16743 
      iprot.readFieldEnd()
16744 
    iprot.readStructEnd()
16745 
 
16746 
  def write(self, oprot):
16747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16749 
      return
16750 
    oprot.writeStructBegin('getOrderForAwb_result')
16751 
    if self.success is not None:
16752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16753 
      self.success.write(oprot)
16754 
      oprot.writeFieldEnd()
16755 
    if self.ex is not None:
16756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16757 
      self.ex.write(oprot)
16758 
      oprot.writeFieldEnd()
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
4506 phani.kuma 16776 
 
16777 
class getOrdersForProviderForStatus_args:
16778 
  """
16779 
  Attributes:
16780 
   - logistics_provider_id
16781 
   - order_status
16782 
  """
16783 
 
16784 
  thrift_spec = (
16785 
    None, # 0
16786 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16787 
    (2, TType.I32, 'order_status', None, None, ), # 2
16788 
  )
16789 
 
16790 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16791 
    self.logistics_provider_id = logistics_provider_id
16792 
    self.order_status = order_status
16793 
 
16794 
  def read(self, iprot):
16795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16797 
      return
16798 
    iprot.readStructBegin()
16799 
    while True:
16800 
      (fname, ftype, fid) = iprot.readFieldBegin()
16801 
      if ftype == TType.STOP:
16802 
        break
16803 
      if fid == 1:
16804 
        if ftype == TType.I64:
16805 
          self.logistics_provider_id = iprot.readI64();
16806 
        else:
16807 
          iprot.skip(ftype)
16808 
      elif fid == 2:
16809 
        if ftype == TType.I32:
16810 
          self.order_status = iprot.readI32();
16811 
        else:
16812 
          iprot.skip(ftype)
16813 
      else:
16814 
        iprot.skip(ftype)
16815 
      iprot.readFieldEnd()
16816 
    iprot.readStructEnd()
16817 
 
16818 
  def write(self, oprot):
16819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16821 
      return
16822 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16823 
    if self.logistics_provider_id is not None:
16824 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16825 
      oprot.writeI64(self.logistics_provider_id)
16826 
      oprot.writeFieldEnd()
16827 
    if self.order_status is not None:
16828 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16829 
      oprot.writeI32(self.order_status)
16830 
      oprot.writeFieldEnd()
16831 
    oprot.writeFieldStop()
16832 
    oprot.writeStructEnd()
16833 
 
16834 
  def validate(self):
16835 
    return
16836 
 
16837 
 
16838 
  def __repr__(self):
16839 
    L = ['%s=%r' % (key, value)
16840 
      for key, value in self.__dict__.iteritems()]
16841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16842 
 
16843 
  def __eq__(self, other):
16844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16845 
 
16846 
  def __ne__(self, other):
16847 
    return not (self == other)
16848 
 
16849 
class getOrdersForProviderForStatus_result:
16850 
  """
16851 
  Attributes:
16852 
   - success
16853 
   - ex
16854 
  """
16855 
 
16856 
  thrift_spec = (
16857 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16859 
  )
16860 
 
16861 
  def __init__(self, success=None, ex=None,):
16862 
    self.success = success
16863 
    self.ex = ex
16864 
 
16865 
  def read(self, iprot):
16866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16868 
      return
16869 
    iprot.readStructBegin()
16870 
    while True:
16871 
      (fname, ftype, fid) = iprot.readFieldBegin()
16872 
      if ftype == TType.STOP:
16873 
        break
16874 
      if fid == 0:
16875 
        if ftype == TType.LIST:
16876 
          self.success = []
4586 mandeep.dh 16877 
          (_etype287, _size284) = iprot.readListBegin()
16878 
          for _i288 in xrange(_size284):
16879 
            _elem289 = Order()
16880 
            _elem289.read(iprot)
16881 
            self.success.append(_elem289)
4506 phani.kuma 16882 
          iprot.readListEnd()
16883 
        else:
16884 
          iprot.skip(ftype)
16885 
      elif fid == 1:
16886 
        if ftype == TType.STRUCT:
16887 
          self.ex = TransactionServiceException()
16888 
          self.ex.read(iprot)
16889 
        else:
16890 
          iprot.skip(ftype)
16891 
      else:
16892 
        iprot.skip(ftype)
16893 
      iprot.readFieldEnd()
16894 
    iprot.readStructEnd()
16895 
 
16896 
  def write(self, oprot):
16897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16899 
      return
16900 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16901 
    if self.success is not None:
16902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 16904 
      for iter290 in self.success:
16905 
        iter290.write(oprot)
4506 phani.kuma 16906 
      oprot.writeListEnd()
16907 
      oprot.writeFieldEnd()
16908 
    if self.ex is not None:
16909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16910 
      self.ex.write(oprot)
16911 
      oprot.writeFieldEnd()
16912 
    oprot.writeFieldStop()
16913 
    oprot.writeStructEnd()
16914 
 
16915 
  def validate(self):
16916 
    return
16917 
 
16918 
 
16919 
  def __repr__(self):
16920 
    L = ['%s=%r' % (key, value)
16921 
      for key, value in self.__dict__.iteritems()]
16922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16923 
 
16924 
  def __eq__(self, other):
16925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16926 
 
16927 
  def __ne__(self, other):
16928 
    return not (self == other)
4600 varun.gupt 16929 
 
16930 
class getBilledOrdersForVendor_args:
16931 
  """
16932 
  Attributes:
16933 
   - vendorId
16934 
   - billingDateFrom
16935 
   - billingDateTo
16936 
  """
16937 
 
16938 
  thrift_spec = (
16939 
    None, # 0
16940 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16941 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
16942 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
16943 
  )
16944 
 
16945 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
16946 
    self.vendorId = vendorId
16947 
    self.billingDateFrom = billingDateFrom
16948 
    self.billingDateTo = billingDateTo
16949 
 
16950 
  def read(self, iprot):
16951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16953 
      return
16954 
    iprot.readStructBegin()
16955 
    while True:
16956 
      (fname, ftype, fid) = iprot.readFieldBegin()
16957 
      if ftype == TType.STOP:
16958 
        break
16959 
      if fid == 1:
16960 
        if ftype == TType.I64:
16961 
          self.vendorId = iprot.readI64();
16962 
        else:
16963 
          iprot.skip(ftype)
16964 
      elif fid == 2:
16965 
        if ftype == TType.I64:
16966 
          self.billingDateFrom = iprot.readI64();
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      elif fid == 3:
16970 
        if ftype == TType.I64:
16971 
          self.billingDateTo = iprot.readI64();
16972 
        else:
16973 
          iprot.skip(ftype)
16974 
      else:
16975 
        iprot.skip(ftype)
16976 
      iprot.readFieldEnd()
16977 
    iprot.readStructEnd()
16978 
 
16979 
  def write(self, oprot):
16980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16982 
      return
16983 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
16984 
    if self.vendorId is not None:
16985 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16986 
      oprot.writeI64(self.vendorId)
16987 
      oprot.writeFieldEnd()
16988 
    if self.billingDateFrom is not None:
16989 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
16990 
      oprot.writeI64(self.billingDateFrom)
16991 
      oprot.writeFieldEnd()
16992 
    if self.billingDateTo is not None:
16993 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
16994 
      oprot.writeI64(self.billingDateTo)
16995 
      oprot.writeFieldEnd()
16996 
    oprot.writeFieldStop()
16997 
    oprot.writeStructEnd()
16998 
 
16999 
  def validate(self):
17000 
    return
17001 
 
17002 
 
17003 
  def __repr__(self):
17004 
    L = ['%s=%r' % (key, value)
17005 
      for key, value in self.__dict__.iteritems()]
17006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17007 
 
17008 
  def __eq__(self, other):
17009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17010 
 
17011 
  def __ne__(self, other):
17012 
    return not (self == other)
17013 
 
17014 
class getBilledOrdersForVendor_result:
17015 
  """
17016 
  Attributes:
17017 
   - success
17018 
   - ex
17019 
  """
17020 
 
17021 
  thrift_spec = (
17022 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17024 
  )
17025 
 
17026 
  def __init__(self, success=None, ex=None,):
17027 
    self.success = success
17028 
    self.ex = ex
17029 
 
17030 
  def read(self, iprot):
17031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17033 
      return
17034 
    iprot.readStructBegin()
17035 
    while True:
17036 
      (fname, ftype, fid) = iprot.readFieldBegin()
17037 
      if ftype == TType.STOP:
17038 
        break
17039 
      if fid == 0:
17040 
        if ftype == TType.LIST:
17041 
          self.success = []
17042 
          (_etype294, _size291) = iprot.readListBegin()
17043 
          for _i295 in xrange(_size291):
17044 
            _elem296 = Order()
17045 
            _elem296.read(iprot)
17046 
            self.success.append(_elem296)
17047 
          iprot.readListEnd()
17048 
        else:
17049 
          iprot.skip(ftype)
17050 
      elif fid == 1:
17051 
        if ftype == TType.STRUCT:
17052 
          self.ex = TransactionServiceException()
17053 
          self.ex.read(iprot)
17054 
        else:
17055 
          iprot.skip(ftype)
17056 
      else:
17057 
        iprot.skip(ftype)
17058 
      iprot.readFieldEnd()
17059 
    iprot.readStructEnd()
17060 
 
17061 
  def write(self, oprot):
17062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17064 
      return
17065 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17066 
    if self.success is not None:
17067 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17068 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17069 
      for iter297 in self.success:
17070 
        iter297.write(oprot)
17071 
      oprot.writeListEnd()
17072 
      oprot.writeFieldEnd()
17073 
    if self.ex is not None:
17074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17075 
      self.ex.write(oprot)
17076 
      oprot.writeFieldEnd()
17077 
    oprot.writeFieldStop()
17078 
    oprot.writeStructEnd()
17079 
 
17080 
  def validate(self):
17081 
    return
17082 
 
17083 
 
17084 
  def __repr__(self):
17085 
    L = ['%s=%r' % (key, value)
17086 
      for key, value in self.__dict__.iteritems()]
17087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17088 
 
17089 
  def __eq__(self, other):
17090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17091 
 
17092 
  def __ne__(self, other):
17093 
    return not (self == other)
17094 
 
17095 
class saveBluedartSettlements_args:
17096 
  """
17097 
  Attributes:
17098 
   - mapAWBAndAmount
17099 
  """
17100 
 
17101 
  thrift_spec = (
17102 
    None, # 0
17103 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17104 
  )
17105 
 
17106 
  def __init__(self, mapAWBAndAmount=None,):
17107 
    self.mapAWBAndAmount = mapAWBAndAmount
17108 
 
17109 
  def read(self, iprot):
17110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17112 
      return
17113 
    iprot.readStructBegin()
17114 
    while True:
17115 
      (fname, ftype, fid) = iprot.readFieldBegin()
17116 
      if ftype == TType.STOP:
17117 
        break
17118 
      if fid == 1:
17119 
        if ftype == TType.MAP:
17120 
          self.mapAWBAndAmount = {}
17121 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
17122 
          for _i302 in xrange(_size298):
17123 
            _key303 = iprot.readI64();
17124 
            _val304 = iprot.readDouble();
17125 
            self.mapAWBAndAmount[_key303] = _val304
17126 
          iprot.readMapEnd()
17127 
        else:
17128 
          iprot.skip(ftype)
17129 
      else:
17130 
        iprot.skip(ftype)
17131 
      iprot.readFieldEnd()
17132 
    iprot.readStructEnd()
17133 
 
17134 
  def write(self, oprot):
17135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17137 
      return
17138 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17139 
    if self.mapAWBAndAmount is not None:
17140 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17141 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
17142 
      for kiter305,viter306 in self.mapAWBAndAmount.items():
17143 
        oprot.writeI64(kiter305)
17144 
        oprot.writeDouble(viter306)
17145 
      oprot.writeMapEnd()
17146 
      oprot.writeFieldEnd()
17147 
    oprot.writeFieldStop()
17148 
    oprot.writeStructEnd()
17149 
 
17150 
  def validate(self):
17151 
    return
17152 
 
17153 
 
17154 
  def __repr__(self):
17155 
    L = ['%s=%r' % (key, value)
17156 
      for key, value in self.__dict__.iteritems()]
17157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17158 
 
17159 
  def __eq__(self, other):
17160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17161 
 
17162 
  def __ne__(self, other):
17163 
    return not (self == other)
17164 
 
17165 
class saveBluedartSettlements_result:
17166 
  """
17167 
  Attributes:
17168 
   - ex
17169 
  """
17170 
 
17171 
  thrift_spec = (
17172 
    None, # 0
17173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17174 
  )
17175 
 
17176 
  def __init__(self, ex=None,):
17177 
    self.ex = ex
17178 
 
17179 
  def read(self, iprot):
17180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17182 
      return
17183 
    iprot.readStructBegin()
17184 
    while True:
17185 
      (fname, ftype, fid) = iprot.readFieldBegin()
17186 
      if ftype == TType.STOP:
17187 
        break
17188 
      if fid == 1:
17189 
        if ftype == TType.STRUCT:
17190 
          self.ex = TransactionServiceException()
17191 
          self.ex.read(iprot)
17192 
        else:
17193 
          iprot.skip(ftype)
17194 
      else:
17195 
        iprot.skip(ftype)
17196 
      iprot.readFieldEnd()
17197 
    iprot.readStructEnd()
17198 
 
17199 
  def write(self, oprot):
17200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17202 
      return
17203 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17204 
    if self.ex is not None:
17205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17206 
      self.ex.write(oprot)
17207 
      oprot.writeFieldEnd()
17208 
    oprot.writeFieldStop()
17209 
    oprot.writeStructEnd()
17210 
 
17211 
  def validate(self):
17212 
    return
17213 
 
17214 
 
17215 
  def __repr__(self):
17216 
    L = ['%s=%r' % (key, value)
17217 
      for key, value in self.__dict__.iteritems()]
17218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17219 
 
17220 
  def __eq__(self, other):
17221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17222 
 
17223 
  def __ne__(self, other):
17224 
    return not (self == other)
17225 
 
17226 
class savePaymentSettlements_args:
17227 
  """
17228 
  Attributes:
17229 
   - settlementDate
17230 
   - paymentGatewayId
17231 
   - paymentId
17232 
   - serviceTax
17233 
   - otherCharges
17234 
   - netCollection
17235 
  """
17236 
 
17237 
  thrift_spec = (
17238 
    None, # 0
17239 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17240 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17241 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17242 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17243 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17244 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17245 
  )
17246 
 
17247 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17248 
    self.settlementDate = settlementDate
17249 
    self.paymentGatewayId = paymentGatewayId
17250 
    self.paymentId = paymentId
17251 
    self.serviceTax = serviceTax
17252 
    self.otherCharges = otherCharges
17253 
    self.netCollection = netCollection
17254 
 
17255 
  def read(self, iprot):
17256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17258 
      return
17259 
    iprot.readStructBegin()
17260 
    while True:
17261 
      (fname, ftype, fid) = iprot.readFieldBegin()
17262 
      if ftype == TType.STOP:
17263 
        break
17264 
      if fid == 1:
17265 
        if ftype == TType.I64:
17266 
          self.settlementDate = iprot.readI64();
17267 
        else:
17268 
          iprot.skip(ftype)
17269 
      elif fid == 2:
17270 
        if ftype == TType.I64:
17271 
          self.paymentGatewayId = iprot.readI64();
17272 
        else:
17273 
          iprot.skip(ftype)
17274 
      elif fid == 3:
17275 
        if ftype == TType.I64:
17276 
          self.paymentId = iprot.readI64();
17277 
        else:
17278 
          iprot.skip(ftype)
17279 
      elif fid == 4:
17280 
        if ftype == TType.DOUBLE:
17281 
          self.serviceTax = iprot.readDouble();
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      elif fid == 5:
17285 
        if ftype == TType.DOUBLE:
17286 
          self.otherCharges = iprot.readDouble();
17287 
        else:
17288 
          iprot.skip(ftype)
17289 
      elif fid == 6:
17290 
        if ftype == TType.DOUBLE:
17291 
          self.netCollection = iprot.readDouble();
17292 
        else:
17293 
          iprot.skip(ftype)
17294 
      else:
17295 
        iprot.skip(ftype)
17296 
      iprot.readFieldEnd()
17297 
    iprot.readStructEnd()
17298 
 
17299 
  def write(self, oprot):
17300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17302 
      return
17303 
    oprot.writeStructBegin('savePaymentSettlements_args')
17304 
    if self.settlementDate is not None:
17305 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17306 
      oprot.writeI64(self.settlementDate)
17307 
      oprot.writeFieldEnd()
17308 
    if self.paymentGatewayId is not None:
17309 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17310 
      oprot.writeI64(self.paymentGatewayId)
17311 
      oprot.writeFieldEnd()
17312 
    if self.paymentId is not None:
17313 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17314 
      oprot.writeI64(self.paymentId)
17315 
      oprot.writeFieldEnd()
17316 
    if self.serviceTax is not None:
17317 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17318 
      oprot.writeDouble(self.serviceTax)
17319 
      oprot.writeFieldEnd()
17320 
    if self.otherCharges is not None:
17321 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17322 
      oprot.writeDouble(self.otherCharges)
17323 
      oprot.writeFieldEnd()
17324 
    if self.netCollection is not None:
17325 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17326 
      oprot.writeDouble(self.netCollection)
17327 
      oprot.writeFieldEnd()
17328 
    oprot.writeFieldStop()
17329 
    oprot.writeStructEnd()
17330 
 
17331 
  def validate(self):
17332 
    return
17333 
 
17334 
 
17335 
  def __repr__(self):
17336 
    L = ['%s=%r' % (key, value)
17337 
      for key, value in self.__dict__.iteritems()]
17338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17339 
 
17340 
  def __eq__(self, other):
17341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17342 
 
17343 
  def __ne__(self, other):
17344 
    return not (self == other)
17345 
 
17346 
class savePaymentSettlements_result:
17347 
  """
17348 
  Attributes:
17349 
   - ex
17350 
  """
17351 
 
17352 
  thrift_spec = (
17353 
    None, # 0
17354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17355 
  )
17356 
 
17357 
  def __init__(self, ex=None,):
17358 
    self.ex = ex
17359 
 
17360 
  def read(self, iprot):
17361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17363 
      return
17364 
    iprot.readStructBegin()
17365 
    while True:
17366 
      (fname, ftype, fid) = iprot.readFieldBegin()
17367 
      if ftype == TType.STOP:
17368 
        break
17369 
      if fid == 1:
17370 
        if ftype == TType.STRUCT:
17371 
          self.ex = TransactionServiceException()
17372 
          self.ex.read(iprot)
17373 
        else:
17374 
          iprot.skip(ftype)
17375 
      else:
17376 
        iprot.skip(ftype)
17377 
      iprot.readFieldEnd()
17378 
    iprot.readStructEnd()
17379 
 
17380 
  def write(self, oprot):
17381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17383 
      return
17384 
    oprot.writeStructBegin('savePaymentSettlements_result')
17385 
    if self.ex is not None:
17386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17387 
      self.ex.write(oprot)
17388 
      oprot.writeFieldEnd()
17389 
    oprot.writeFieldStop()
17390 
    oprot.writeStructEnd()
17391 
 
17392 
  def validate(self):
17393 
    return
17394 
 
17395 
 
17396 
  def __repr__(self):
17397 
    L = ['%s=%r' % (key, value)
17398 
      for key, value in self.__dict__.iteritems()]
17399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17400 
 
17401 
  def __eq__(self, other):
17402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17403 
 
17404 
  def __ne__(self, other):
17405 
    return not (self == other)
17406 
 
17407 
class saveEBSSettlementSummary_args:
17408 
  """
17409 
  Attributes:
17410 
   - settlementId
17411 
   - settlementDate
17412 
   - transactionDateFrom
17413 
   - transactionDateTo
17414 
   - amount
17415 
  """
17416 
 
17417 
  thrift_spec = (
17418 
    None, # 0
17419 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17420 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
17421 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
17422 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
17423 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
17424 
  )
17425 
 
17426 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
17427 
    self.settlementId = settlementId
17428 
    self.settlementDate = settlementDate
17429 
    self.transactionDateFrom = transactionDateFrom
17430 
    self.transactionDateTo = transactionDateTo
17431 
    self.amount = amount
17432 
 
17433 
  def read(self, iprot):
17434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17436 
      return
17437 
    iprot.readStructBegin()
17438 
    while True:
17439 
      (fname, ftype, fid) = iprot.readFieldBegin()
17440 
      if ftype == TType.STOP:
17441 
        break
17442 
      if fid == 1:
17443 
        if ftype == TType.I64:
17444 
          self.settlementId = iprot.readI64();
17445 
        else:
17446 
          iprot.skip(ftype)
17447 
      elif fid == 2:
17448 
        if ftype == TType.I64:
17449 
          self.settlementDate = iprot.readI64();
17450 
        else:
17451 
          iprot.skip(ftype)
17452 
      elif fid == 3:
17453 
        if ftype == TType.I64:
17454 
          self.transactionDateFrom = iprot.readI64();
17455 
        else:
17456 
          iprot.skip(ftype)
17457 
      elif fid == 4:
17458 
        if ftype == TType.I64:
17459 
          self.transactionDateTo = iprot.readI64();
17460 
        else:
17461 
          iprot.skip(ftype)
17462 
      elif fid == 5:
17463 
        if ftype == TType.DOUBLE:
17464 
          self.amount = iprot.readDouble();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      else:
17468 
        iprot.skip(ftype)
17469 
      iprot.readFieldEnd()
17470 
    iprot.readStructEnd()
17471 
 
17472 
  def write(self, oprot):
17473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17475 
      return
17476 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
17477 
    if self.settlementId is not None:
17478 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17479 
      oprot.writeI64(self.settlementId)
17480 
      oprot.writeFieldEnd()
17481 
    if self.settlementDate is not None:
17482 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
17483 
      oprot.writeI64(self.settlementDate)
17484 
      oprot.writeFieldEnd()
17485 
    if self.transactionDateFrom is not None:
17486 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
17487 
      oprot.writeI64(self.transactionDateFrom)
17488 
      oprot.writeFieldEnd()
17489 
    if self.transactionDateTo is not None:
17490 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
17491 
      oprot.writeI64(self.transactionDateTo)
17492 
      oprot.writeFieldEnd()
17493 
    if self.amount is not None:
17494 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
17495 
      oprot.writeDouble(self.amount)
17496 
      oprot.writeFieldEnd()
17497 
    oprot.writeFieldStop()
17498 
    oprot.writeStructEnd()
17499 
 
17500 
  def validate(self):
17501 
    return
17502 
 
17503 
 
17504 
  def __repr__(self):
17505 
    L = ['%s=%r' % (key, value)
17506 
      for key, value in self.__dict__.iteritems()]
17507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17508 
 
17509 
  def __eq__(self, other):
17510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17511 
 
17512 
  def __ne__(self, other):
17513 
    return not (self == other)
17514 
 
17515 
class saveEBSSettlementSummary_result:
17516 
  """
17517 
  Attributes:
17518 
   - ex
17519 
  """
17520 
 
17521 
  thrift_spec = (
17522 
    None, # 0
17523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17524 
  )
17525 
 
17526 
  def __init__(self, ex=None,):
17527 
    self.ex = ex
17528 
 
17529 
  def read(self, iprot):
17530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17532 
      return
17533 
    iprot.readStructBegin()
17534 
    while True:
17535 
      (fname, ftype, fid) = iprot.readFieldBegin()
17536 
      if ftype == TType.STOP:
17537 
        break
17538 
      if fid == 1:
17539 
        if ftype == TType.STRUCT:
17540 
          self.ex = TransactionServiceException()
17541 
          self.ex.read(iprot)
17542 
        else:
17543 
          iprot.skip(ftype)
17544 
      else:
17545 
        iprot.skip(ftype)
17546 
      iprot.readFieldEnd()
17547 
    iprot.readStructEnd()
17548 
 
17549 
  def write(self, oprot):
17550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17552 
      return
17553 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
17554 
    if self.ex is not None:
17555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17556 
      self.ex.write(oprot)
17557 
      oprot.writeFieldEnd()
17558 
    oprot.writeFieldStop()
17559 
    oprot.writeStructEnd()
17560 
 
17561 
  def validate(self):
17562 
    return
17563 
 
17564 
 
17565 
  def __repr__(self):
17566 
    L = ['%s=%r' % (key, value)
17567 
      for key, value in self.__dict__.iteritems()]
17568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17569 
 
17570 
  def __eq__(self, other):
17571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17572 
 
17573 
  def __ne__(self, other):
17574 
    return not (self == other)
17575 
 
17576 
class getSettlementForPaymentId_args:
17577 
  """
17578 
  Attributes:
17579 
   - paymentId
17580 
  """
17581 
 
17582 
  thrift_spec = (
17583 
    None, # 0
17584 
    (1, TType.I64, 'paymentId', None, None, ), # 1
17585 
  )
17586 
 
17587 
  def __init__(self, paymentId=None,):
17588 
    self.paymentId = paymentId
17589 
 
17590 
  def read(self, iprot):
17591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17593 
      return
17594 
    iprot.readStructBegin()
17595 
    while True:
17596 
      (fname, ftype, fid) = iprot.readFieldBegin()
17597 
      if ftype == TType.STOP:
17598 
        break
17599 
      if fid == 1:
17600 
        if ftype == TType.I64:
17601 
          self.paymentId = iprot.readI64();
17602 
        else:
17603 
          iprot.skip(ftype)
17604 
      else:
17605 
        iprot.skip(ftype)
17606 
      iprot.readFieldEnd()
17607 
    iprot.readStructEnd()
17608 
 
17609 
  def write(self, oprot):
17610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17612 
      return
17613 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
17614 
    if self.paymentId is not None:
17615 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
17616 
      oprot.writeI64(self.paymentId)
17617 
      oprot.writeFieldEnd()
17618 
    oprot.writeFieldStop()
17619 
    oprot.writeStructEnd()
17620 
 
17621 
  def validate(self):
17622 
    return
17623 
 
17624 
 
17625 
  def __repr__(self):
17626 
    L = ['%s=%r' % (key, value)
17627 
      for key, value in self.__dict__.iteritems()]
17628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17629 
 
17630 
  def __eq__(self, other):
17631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17632 
 
17633 
  def __ne__(self, other):
17634 
    return not (self == other)
17635 
 
17636 
class getSettlementForPaymentId_result:
17637 
  """
17638 
  Attributes:
17639 
   - success
17640 
   - ex
17641 
  """
17642 
 
17643 
  thrift_spec = (
17644 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
17645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17646 
  )
17647 
 
17648 
  def __init__(self, success=None, ex=None,):
17649 
    self.success = success
17650 
    self.ex = ex
17651 
 
17652 
  def read(self, iprot):
17653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17655 
      return
17656 
    iprot.readStructBegin()
17657 
    while True:
17658 
      (fname, ftype, fid) = iprot.readFieldBegin()
17659 
      if ftype == TType.STOP:
17660 
        break
17661 
      if fid == 0:
17662 
        if ftype == TType.STRUCT:
17663 
          self.success = PaymentSettlement()
17664 
          self.success.read(iprot)
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      elif fid == 1:
17668 
        if ftype == TType.STRUCT:
17669 
          self.ex = TransactionServiceException()
17670 
          self.ex.read(iprot)
17671 
        else:
17672 
          iprot.skip(ftype)
17673 
      else:
17674 
        iprot.skip(ftype)
17675 
      iprot.readFieldEnd()
17676 
    iprot.readStructEnd()
17677 
 
17678 
  def write(self, oprot):
17679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17681 
      return
17682 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
17683 
    if self.success is not None:
17684 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17685 
      self.success.write(oprot)
17686 
      oprot.writeFieldEnd()
17687 
    if self.ex is not None:
17688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17689 
      self.ex.write(oprot)
17690 
      oprot.writeFieldEnd()
17691 
    oprot.writeFieldStop()
17692 
    oprot.writeStructEnd()
17693 
 
17694 
  def validate(self):
17695 
    return
17696 
 
17697 
 
17698 
  def __repr__(self):
17699 
    L = ['%s=%r' % (key, value)
17700 
      for key, value in self.__dict__.iteritems()]
17701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17702 
 
17703 
  def __eq__(self, other):
17704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17705 
 
17706 
  def __ne__(self, other):
17707 
    return not (self == other)
17708 
 
17709 
class getEBSSettlementSummaries_args:
17710 
 
17711 
  thrift_spec = (
17712 
  )
17713 
 
17714 
  def read(self, iprot):
17715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17717 
      return
17718 
    iprot.readStructBegin()
17719 
    while True:
17720 
      (fname, ftype, fid) = iprot.readFieldBegin()
17721 
      if ftype == TType.STOP:
17722 
        break
17723 
      else:
17724 
        iprot.skip(ftype)
17725 
      iprot.readFieldEnd()
17726 
    iprot.readStructEnd()
17727 
 
17728 
  def write(self, oprot):
17729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17731 
      return
17732 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
17733 
    oprot.writeFieldStop()
17734 
    oprot.writeStructEnd()
17735 
 
17736 
  def validate(self):
17737 
    return
17738 
 
17739 
 
17740 
  def __repr__(self):
17741 
    L = ['%s=%r' % (key, value)
17742 
      for key, value in self.__dict__.iteritems()]
17743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17744 
 
17745 
  def __eq__(self, other):
17746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17747 
 
17748 
  def __ne__(self, other):
17749 
    return not (self == other)
17750 
 
17751 
class getEBSSettlementSummaries_result:
17752 
  """
17753 
  Attributes:
17754 
   - success
17755 
   - ex
17756 
  """
17757 
 
17758 
  thrift_spec = (
17759 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
17760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17761 
  )
17762 
 
17763 
  def __init__(self, success=None, ex=None,):
17764 
    self.success = success
17765 
    self.ex = ex
17766 
 
17767 
  def read(self, iprot):
17768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17770 
      return
17771 
    iprot.readStructBegin()
17772 
    while True:
17773 
      (fname, ftype, fid) = iprot.readFieldBegin()
17774 
      if ftype == TType.STOP:
17775 
        break
17776 
      if fid == 0:
17777 
        if ftype == TType.MAP:
17778 
          self.success = {}
17779 
          (_ktype308, _vtype309, _size307 ) = iprot.readMapBegin()
17780 
          for _i311 in xrange(_size307):
17781 
            _key312 = iprot.readI64();
17782 
            _val313 = iprot.readString();
17783 
            self.success[_key312] = _val313
17784 
          iprot.readMapEnd()
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      elif fid == 1:
17788 
        if ftype == TType.STRUCT:
17789 
          self.ex = TransactionServiceException()
17790 
          self.ex.read(iprot)
17791 
        else:
17792 
          iprot.skip(ftype)
17793 
      else:
17794 
        iprot.skip(ftype)
17795 
      iprot.readFieldEnd()
17796 
    iprot.readStructEnd()
17797 
 
17798 
  def write(self, oprot):
17799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17801 
      return
17802 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
17803 
    if self.success is not None:
17804 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17805 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
17806 
      for kiter314,viter315 in self.success.items():
17807 
        oprot.writeI64(kiter314)
17808 
        oprot.writeString(viter315)
17809 
      oprot.writeMapEnd()
17810 
      oprot.writeFieldEnd()
17811 
    if self.ex is not None:
17812 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17813 
      self.ex.write(oprot)
17814 
      oprot.writeFieldEnd()
17815 
    oprot.writeFieldStop()
17816 
    oprot.writeStructEnd()
17817 
 
17818 
  def validate(self):
17819 
    return
17820 
 
17821 
 
17822 
  def __repr__(self):
17823 
    L = ['%s=%r' % (key, value)
17824 
      for key, value in self.__dict__.iteritems()]
17825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17826 
 
17827 
  def __eq__(self, other):
17828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17829 
 
17830 
  def __ne__(self, other):
17831 
    return not (self == other)
17832 
 
17833 
class markEBSSettlementUploaded_args:
17834 
  """
17835 
  Attributes:
17836 
   - settlementId
17837 
  """
17838 
 
17839 
  thrift_spec = (
17840 
    None, # 0
17841 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17842 
  )
17843 
 
17844 
  def __init__(self, settlementId=None,):
17845 
    self.settlementId = settlementId
17846 
 
17847 
  def read(self, iprot):
17848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17850 
      return
17851 
    iprot.readStructBegin()
17852 
    while True:
17853 
      (fname, ftype, fid) = iprot.readFieldBegin()
17854 
      if ftype == TType.STOP:
17855 
        break
17856 
      if fid == 1:
17857 
        if ftype == TType.I64:
17858 
          self.settlementId = iprot.readI64();
17859 
        else:
17860 
          iprot.skip(ftype)
17861 
      else:
17862 
        iprot.skip(ftype)
17863 
      iprot.readFieldEnd()
17864 
    iprot.readStructEnd()
17865 
 
17866 
  def write(self, oprot):
17867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17869 
      return
17870 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
17871 
    if self.settlementId is not None:
17872 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17873 
      oprot.writeI64(self.settlementId)
17874 
      oprot.writeFieldEnd()
17875 
    oprot.writeFieldStop()
17876 
    oprot.writeStructEnd()
17877 
 
17878 
  def validate(self):
17879 
    return
17880 
 
17881 
 
17882 
  def __repr__(self):
17883 
    L = ['%s=%r' % (key, value)
17884 
      for key, value in self.__dict__.iteritems()]
17885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17886 
 
17887 
  def __eq__(self, other):
17888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17889 
 
17890 
  def __ne__(self, other):
17891 
    return not (self == other)
17892 
 
17893 
class markEBSSettlementUploaded_result:
17894 
  """
17895 
  Attributes:
17896 
   - ex
17897 
  """
17898 
 
17899 
  thrift_spec = (
17900 
    None, # 0
17901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17902 
  )
17903 
 
17904 
  def __init__(self, ex=None,):
17905 
    self.ex = ex
17906 
 
17907 
  def read(self, iprot):
17908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17910 
      return
17911 
    iprot.readStructBegin()
17912 
    while True:
17913 
      (fname, ftype, fid) = iprot.readFieldBegin()
17914 
      if ftype == TType.STOP:
17915 
        break
17916 
      if fid == 1:
17917 
        if ftype == TType.STRUCT:
17918 
          self.ex = TransactionServiceException()
17919 
          self.ex.read(iprot)
17920 
        else:
17921 
          iprot.skip(ftype)
17922 
      else:
17923 
        iprot.skip(ftype)
17924 
      iprot.readFieldEnd()
17925 
    iprot.readStructEnd()
17926 
 
17927 
  def write(self, oprot):
17928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17930 
      return
17931 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
17932 
    if self.ex is not None:
17933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17934 
      self.ex.write(oprot)
17935 
      oprot.writeFieldEnd()
17936 
    oprot.writeFieldStop()
17937 
    oprot.writeStructEnd()
17938 
 
17939 
  def validate(self):
17940 
    return
17941 
 
17942 
 
17943 
  def __repr__(self):
17944 
    L = ['%s=%r' % (key, value)
17945 
      for key, value in self.__dict__.iteritems()]
17946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17947 
 
17948 
  def __eq__(self, other):
17949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17950 
 
17951 
  def __ne__(self, other):
17952 
    return not (self == other)
17953 
 
17954 
class getEBSSettlementDate_args:
17955 
  """
17956 
  Attributes:
17957 
   - settlementId
17958 
  """
17959 
 
17960 
  thrift_spec = (
17961 
    None, # 0
17962 
    (1, TType.I64, 'settlementId', None, None, ), # 1
17963 
  )
17964 
 
17965 
  def __init__(self, settlementId=None,):
17966 
    self.settlementId = settlementId
17967 
 
17968 
  def read(self, iprot):
17969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17971 
      return
17972 
    iprot.readStructBegin()
17973 
    while True:
17974 
      (fname, ftype, fid) = iprot.readFieldBegin()
17975 
      if ftype == TType.STOP:
17976 
        break
17977 
      if fid == 1:
17978 
        if ftype == TType.I64:
17979 
          self.settlementId = iprot.readI64();
17980 
        else:
17981 
          iprot.skip(ftype)
17982 
      else:
17983 
        iprot.skip(ftype)
17984 
      iprot.readFieldEnd()
17985 
    iprot.readStructEnd()
17986 
 
17987 
  def write(self, oprot):
17988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17990 
      return
17991 
    oprot.writeStructBegin('getEBSSettlementDate_args')
17992 
    if self.settlementId is not None:
17993 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
17994 
      oprot.writeI64(self.settlementId)
17995 
      oprot.writeFieldEnd()
17996 
    oprot.writeFieldStop()
17997 
    oprot.writeStructEnd()
17998 
 
17999 
  def validate(self):
18000 
    return
18001 
 
18002 
 
18003 
  def __repr__(self):
18004 
    L = ['%s=%r' % (key, value)
18005 
      for key, value in self.__dict__.iteritems()]
18006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18007 
 
18008 
  def __eq__(self, other):
18009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18010 
 
18011 
  def __ne__(self, other):
18012 
    return not (self == other)
18013 
 
18014 
class getEBSSettlementDate_result:
18015 
  """
18016 
  Attributes:
18017 
   - success
18018 
   - ex
18019 
  """
18020 
 
18021 
  thrift_spec = (
18022 
    (0, TType.I64, 'success', None, None, ), # 0
18023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18024 
  )
18025 
 
18026 
  def __init__(self, success=None, ex=None,):
18027 
    self.success = success
18028 
    self.ex = ex
18029 
 
18030 
  def read(self, iprot):
18031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18033 
      return
18034 
    iprot.readStructBegin()
18035 
    while True:
18036 
      (fname, ftype, fid) = iprot.readFieldBegin()
18037 
      if ftype == TType.STOP:
18038 
        break
18039 
      if fid == 0:
18040 
        if ftype == TType.I64:
18041 
          self.success = iprot.readI64();
18042 
        else:
18043 
          iprot.skip(ftype)
18044 
      elif fid == 1:
18045 
        if ftype == TType.STRUCT:
18046 
          self.ex = TransactionServiceException()
18047 
          self.ex.read(iprot)
18048 
        else:
18049 
          iprot.skip(ftype)
18050 
      else:
18051 
        iprot.skip(ftype)
18052 
      iprot.readFieldEnd()
18053 
    iprot.readStructEnd()
18054 
 
18055 
  def write(self, oprot):
18056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18058 
      return
18059 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18060 
    if self.success is not None:
18061 
      oprot.writeFieldBegin('success', TType.I64, 0)
18062 
      oprot.writeI64(self.success)
18063 
      oprot.writeFieldEnd()
18064 
    if self.ex is not None:
18065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18066 
      self.ex.write(oprot)
18067 
      oprot.writeFieldEnd()
18068 
    oprot.writeFieldStop()
18069 
    oprot.writeStructEnd()
18070 
 
18071 
  def validate(self):
18072 
    return
18073 
 
18074 
 
18075 
  def __repr__(self):
18076 
    L = ['%s=%r' % (key, value)
18077 
      for key, value in self.__dict__.iteritems()]
18078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18079 
 
18080 
  def __eq__(self, other):
18081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18082 
 
18083 
  def __ne__(self, other):
18084 
    return not (self == other)